physical_digital

type AcousticManipulationEngine struct{}

type AdaptationEngine struct{}

type AdaptationLogic struct {
	LogicType  string
	Parameters map[string]interface{}
}

type Area3D struct {
	Width, Height, Depth float64
}

type AreaType int

type AttackVector int

type BehaviorChangeType int

type BiometricSpoofingEngine struct{}

type BridgeAttack struct {
	AttackID             string
	AttackType           BridgeAttackType
	AttackVector         AttackVector
	PhysicalComponents   []PhysicalComponent
	DigitalComponents    []DigitalComponent
	BridgePoints         []BridgePoint
	StartTime            time.Time
	Duration             time.Duration
	SynchronizationReq   *SynchronizationRequirement
	EnvironmentalContext *EnvironmentalContext
	SuccessMetrics       *BridgeSuccessMetrics
	Metadata             map[string]interface{}
}

type BridgeAttackExecution struct {
	ExecutionID        string
	AttackPlan         *BridgeAttackPlan
	TargetSystems      []string
	PhysicalSetup      *PhysicalSetup
	DigitalSetup       *DigitalSetup
	StartTime          time.Time
	EndTime            time.Time
	Status             BridgeExecutionStatus
	Results            *BridgeAttackResults
	SynchronizationLog []SynchronizationEvent
	Metadata           map[string]interface{}
}

type BridgeAttackPlan struct {
	PlanID              string
	AttackSequence      []BridgeAttackStep
	PhysicalPreparation *PhysicalPreparation
	DigitalPreparation  *DigitalPreparation
	SynchronizationPlan *SynchronizationPlan
	ContingencyPlans    []ContingencyPlan
	CleanupPlan         *CleanupPlan
}

type BridgeAttackResults struct {
	StepResults            map[string]*BridgeStepResult
	PhysicalEffects        *PhysicalEffectResults
	DigitalEffects         *DigitalEffectResults
	BridgeEffectiveness    *BridgeEffectivenessMetrics
	SynchronizationResults *SynchronizationResults
	DetectionEvidence      []DetectionEvidence
	UnintendedEffects      []UnintendedEffect
}

type BridgeAttackStep struct {
	StepID              string
	AttackType          BridgeAttackType
	PhysicalActions     []PhysicalAction
	DigitalActions      []DigitalAction
	Timing              StepTiming
	DependsOn           []string
	SuccessRequirements []SuccessRequirement
	FailureHandling     FailureHandling
}

type BridgeAttackType int

type BridgeEffectivenessMetrics struct {
	OverallScore        float64
	PhysicalSuccessRate float64
	DigitalSuccessRate  float64
	BridgeSuccessRate   float64
	DetectionRisk       float64
}

type BridgeExecutionStatus int

type BridgePoint struct {
	BridgeID         string
	PhysicalEndpoint string
	DigitalEndpoint  string
	BridgeType       BridgeType
	Bandwidth        float64
	Latency          time.Duration
	SecurityLevel    int
	MonitoringLevel  int
}

type BridgeStepResult struct {
	StepID               string
	Success              bool
	PhysicalSuccess      bool
	DigitalSuccess       bool
	BridgeSuccess        bool
	EffectivenessScore   float64
	DetectionRisk        float64
	PhysicalMeasurements *PhysicalMeasurements
	DigitalResponses     *DigitalResponses
	SideEffects          []SideEffect
	Duration             time.Duration
}

type BridgeSuccessMetrics struct {
	OverallEffectiveness  float64
	PhysicalEffectiveness float64
	DigitalEffectiveness  float64
	BridgeCorrelation     float64
}

type BridgeType int

type Calibration struct{}

type CleanupAction struct {
	ActionID string
	Type     string
	Target   string
}

type CleanupPlan struct {
	PlanID  string
	Actions []CleanupAction
}

type ColorSpectrum struct {
	Red   float64
	Green float64
	Blue  float64
	Alpha float64
}

type ComponentTiming struct {
	StartDelay      time.Duration
	Duration        time.Duration
	RepeatInterval  time.Duration
	SyncRequirement bool
}

type ContextualMappingEngine struct{}

type ContingencyPlan struct {
	PlanID           string
	TriggerCondition string
	Actions          []string
}

type DataCorruption struct {
	DataType       string
	CorruptionType string
	Severity       float64
	Detectability  float64
}

type DeliveryMethod int

type Dependency struct {
	DependentID string
	DependsOnID string
	Type        string
}

type DetectionEvidence struct {
	EvidenceType string
	Strength     float64
	Source       string
	Timestamp    time.Time
}

type DigitalAction struct {
	ActionID           string
	ActionType         DigitalActionType
	TargetInterface    DigitalInterfaceType
	Payload            DigitalPayload
	DeliveryMethod     DeliveryMethod
	AdaptationLogic    *AdaptationLogic
	VerificationMethod *VerificationMethod
}

type DigitalActionResult struct {
	ActionID     string
	Success      bool
	ResponseData []byte
}

type DigitalActionType int

type DigitalAdaptationRule struct {
	RuleID    string
	Condition string
	Action    string
}

type DigitalComponent struct {
	ComponentID      string
	InterfaceType    DigitalInterfaceType
	TargetSystem     string
	PayloadDelivery  DigitalPayloadDelivery
	AdaptationRules  []DigitalAdaptationRule
	ExpectedResponse ExpectedResponse
	FallbackStrategy []string
}

type DigitalEffectResults struct {
	SystemResponses        map[string]SystemResponse
	ModelBehaviorChanges   []ModelBehaviorChange
	InterfaceManipulations []InterfaceManipulation
	DataCorruptions        []DataCorruption
	SecurityBypassEvents   []SecurityBypassEvent
}

type DigitalInterfaceType int

type DigitalPayload struct {
	PayloadType DigitalPayloadType
	Content     []byte
	ContentType string
	Encoding    string
	Compression bool
	Encryption  bool
	Obfuscation ObfuscationMethod
	TargetModel string
}

type DigitalPayloadDelivery struct {
	DeliveryMethod    DeliveryMethod
	Payload           []byte
	Encoding          string
	Encryption        bool
	Steganography     bool
	TimingConstraints TimingConstraints
}

type DigitalPayloadType int

type DigitalPreparation struct {
	Interfaces []InterfaceConfig
}

type DigitalResponses struct {
	Responses map[string]interface{}
}

type DigitalSetup struct {
	Interfaces        map[string]*InterfaceSetup
	PayloadManagers   map[string]*PayloadManager
	AdaptationEngines map[string]*AdaptationEngine
}

type EnvironmentMapping struct{}

type EnvironmentalChange struct {
	ChangeType    EnvironmentalChangeType
	Magnitude     float64
	Duration      time.Duration
	Location      Position3D
	Reversibility float64
}

type EnvironmentalChangeType int

type EnvironmentalContext struct {
	Location           GeographicalLocation
	Time               time.Time
	WeatherConditions  WeatherConditions
	LightingConditions LightingConditions
	NoiseLevel         float64
	CrowdDensity       float64
	SecurityLevel      SecurityLevel
	DeviceDensity      float64
	NetworkTopology    NetworkTopology
}

type EnvironmentalManipulationEngine struct{}

type ExpectedResponse struct {
	ResponseType        string
	ExpectedContent     []byte
	TimeWindow          time.Duration
	ConfidenceThreshold float64
}

type FailureHandling struct {
	Strategy string
	Retries  int
	Fallback string
}

type GeographicalLocation struct {
	Latitude       float64
	Longitude      float64
	Altitude       float64
	Address        string
	LocationType   LocationType
	IndoorLocation *IndoorLocation
}

type HapticManipulationEngine struct{}

type IndoorLocation struct {
	BuildingType string
	Floor        int
	Room         string
	AreaType     AreaType
}

type InterfaceConfig struct {
	InterfaceID   string
	InterfaceType DigitalInterfaceType
}

type InterfaceManipulation struct {
	InterfaceID      string
	ManipulationType string
	Success          bool
	Impact           float64
}

type InterfaceSetup struct{}

type LightSource struct {
	SourceType  LightSourceType
	Intensity   float64
	Position    Position3D
	Color       ColorSpectrum
	FlickerRate float64
}

type LightSourceType int

type LightingConditions struct {
	LuminanceLevel   float64
	ColorTemperature float64
	LightSources     []LightSource
	ShadowPatterns   []ShadowPattern
}

type LocationSpoofingEngine struct{}

type LocationType int

type ManipulationType int

type ModelBehaviorChange struct {
	ModelID       string
	ChangeType    BehaviorChangeType
	Magnitude     float64
	Duration      time.Duration
	Persistence   float64
	Observability float64
}

type ModulationType int

type MovementPattern struct {
	PatternType  MovementType
	Speed        float64
	Path         []Position3D
	Repetitions  int
	RandomFactor float64
}

type MovementType int

type NetworkTopology struct {
	TopologyType string
	NodeCount    int
	Connectivity float64
}

type ObfuscationMethod int

type OpticalIllusionEngine struct{}

type Orientation3D struct {
	Pitch, Yaw, Roll float64
}

type PayloadManager struct{}

type PhysicalAction struct {
	ActionID     string
	ActionType   PhysicalActionType
	Target       PhysicalTarget
	Parameters   PhysicalParameters
	Duration     time.Duration
	Intensity    float64
	Precision    float64
	StealthLevel float64
}

type PhysicalActionResult struct {
	ActionID     string
	Success      bool
	ResponseData []byte
}

type PhysicalActionType int

type PhysicalComponent struct {
	ComponentID      string
	ComponentType    PhysicalComponentType
	SensorTargets    []PhysicalSensorType
	Manipulation     PhysicalManipulation
	Timing           ComponentTiming
	SynchronizedWith []string
	EffectRadius     float64
	DetectionRisk    float64
}

type PhysicalComponentSetup struct{}

type PhysicalComponentType int

type PhysicalDigitalBridgeEngine struct {
	// contains filtered or unexported fields
}

type PhysicalDisturbance struct {
	DisturbanceType PhysicalDisturbanceType
	Intensity       float64
	Location        Position3D
	Duration        time.Duration
	DetectionRisk   float64
}

type PhysicalDisturbanceType int

type PhysicalEffectResults struct {
	SensorReadings       map[PhysicalSensorType]SensorReading
	EnvironmentalChanges []EnvironmentalChange
	PhysicalDisturbances []PhysicalDisturbance
	EnergyConsumption    float64
	NoiseGenerated       float64
	VisibilityFootprint  float64
}

type PhysicalManipulation struct {
	ManipulationType ManipulationType
	Intensity        float64
	Frequency        float64
	Duration         time.Duration
	WaveformPattern  WaveformPattern
	SpatialPattern   SpatialPattern
	TemporalPattern  TemporalPattern
}

type PhysicalMeasurements struct {
	Measurements map[string]interface{}
}

type PhysicalParameters struct {
	Intensity    float64
	Frequency    float64
	Amplitude    float64
	Phase        float64
	Wavelength   float64
	Polarization float64
	Modulation   ModulationType
	WaveformType WaveformType
}

type PhysicalPreparation struct {
	Components []PhysicalComponent
}

type PhysicalSensorType int

type PhysicalSetup struct {
	Components      map[string]*PhysicalComponentSetup
	Calibrations    map[string]*Calibration
	EnvironmentMap  *EnvironmentMapping
	PowerManagement *PowerManagement
}

type PhysicalTarget struct {
	TargetType      PhysicalTargetType
	Coordinates     Position3D
	Orientation     Orientation3D
	TargetArea      Area3D
	MovementPattern *MovementPattern
}

type PhysicalTargetType int

type Position3D struct {
	X, Y, Z float64
}

type PowerManagement struct{}

type ProximityAttackEngine struct{}

type RFInterferenceEngine struct{}

type ResponseType int

type SecurityBypassEvent struct {
	SecurityControl string
	BypassMethod    string
	Success         bool
	Duration        time.Duration
}

type SecurityLevel int

type SensorReading struct {
	SensorType PhysicalSensorType
	Value      float64
	Timestamp  time.Time
	Confidence float64
	NoiseLevel float64
	Anomalies  []string
}

type SensorSpoofingEngine struct{}

type ShadowPattern struct {
	PatternType string
	Intensity   float64
	Direction   float64
}

type SideEffect struct {
	EffectType string
	Magnitude  float64
	Duration   time.Duration
}

type SpatialPattern string

type StepTiming struct {
	StartTime    time.Time
	Duration     time.Duration
	SyncRequired bool
}

type SuccessRequirement struct {
	RequirementType string
	Criteria        map[string]interface{}
}

type SyncPoint struct {
	PointID   string
	Timestamp time.Time
	Type      string
}

type SynchronizationEvent struct {
	EventID   string
	Timestamp time.Time
	Type      string
	Details   map[string]interface{}
}

type SynchronizationPlan struct {
	SyncPoints   []SyncPoint
	TimingRules  []TimingRule
	Dependencies []Dependency
}

type SynchronizationRequirement struct {
	RequiredPrecision time.Duration
	MaxLatency        time.Duration
	SyncPoints        []string
}

type SynchronizationResults struct {
	SyncAccuracy    float64
	TimingDrift     time.Duration
	SyncFailures    int
	LatencyVariance time.Duration
}

type SystemResponse struct {
	SystemID     string
	ResponseType ResponseType
	ResponseData []byte
	Confidence   float64
	Latency      time.Duration
	Anomalies    []string
}

type TemporalPattern string

type TimingConstraints struct {
	MaxLatency      time.Duration
	TimeWindow      time.Duration
	SyncRequirement bool
}

type TimingRule struct {
	RuleID  string
	Trigger string
	Action  string
}

type UnintendedEffect struct {
	EffectType string
	Severity   float64
	Duration   time.Duration
	Mitigation string
}

type VerificationMethod struct {
	MethodType string
	Criteria   map[string]interface{}
}

type WaveformPattern string

type WaveformType int

type WeatherConditions struct {
	Temperature   float64
	Humidity      float64
	Pressure      float64
	WindSpeed     float64
	WindDirection float64
	Precipitation float64
	Visibility    float64
	UVIndex       float64
}