import { SupportedRepository } from "./supportedRepositories.js";
/** GUID string */
export type Guid = string;
/** String containing only alphanumeric characters */
export type AlphaNumericString = string;
/** Free-text string that blocks any HTML tag (e.g. `<div` or `</div`), URIs (`://`), and the JS protocol (`javascript:`). Standalone `<` or `>` in non-tag contexts (e.g. `x < y`) are allowed. Frontend should treat this as untrusted input and escape or sanitize it before rendering. */
export type SafeString = string;
/** A JavaScript (JSEP) expression for frontend rendering that excludes potentially dangerous constructs. It's up to the frontend to validate and execute this expression safely. */
export type ExpressionString = string;
/** Free-text string that blocks a small set of potentially dangerous patterns (<script, javascript:, data:, <iframe, inline on event handlers). May contain URIs. Frontend should treat this as untrusted input and escape or sanitize it before rendering. */
export type RestrictedString = string;
/** Base64-encoded image data URI. Supported types: `image/png`, `image/jpeg`, `image/svg+xml`, `image/webp`. Maximum decoded size: 20KB. Animated SVGs are not supported. SVG content cannot contain scripts, event handlers, `javascript:` URIs, `foreignObject` elements, or animation elements. */
export type Base64Image = string;
/** HTTPS URL pointing to a publicly hosted resource. Must use a domain name host; raw IP addresses (all ranges, including private and loopback) are disallowed. URLs with embedded credentials are disallowed. */
export type HttpsUrl = string;
/** Expression that determines styling conditions or a single expression. */
export type ExpressionOrConditions = ExpressionString | {
    conditions: {
        condition: ExpressionString;
        expression: ExpressionString;
        label?: SafeString;
    }[];
};
/** A structured expression definition that wraps an expression or conditions with optional reusable variable definitions. */
export type StyleExpression = {
    /** The expression value: either a JSEP expression string or a conditions object. */
    expression: ExpressionOrConditions;
    /** Named variables that can be referenced in expressions and conditions. */
    defines?: {
        [key: string]: ExpressionString;
    };
};
/** Date time in format: YYYY-MM-DDThh:mm:ssZ or YYYY-MM-DDThh:mm:ss.sssZ */
export type DateTime = string;
/** Id64 string. See https://www.itwinjs.org/learning/common/id64/ */
export type Id64 = string;
/** Compressed Id64 set. */
export type CompressedId64Set = string;
export type Vector3d = {
    x: number;
    y: number;
    z: number;
};
/** A set of 4-dimensional coordinates used to represent rotation in 3-dimensional space. */
export type Quaternion = {
    x: number;
    y: number;
    z: number;
    w: number;
};
/** Array of 16 numbers representing a 4x4 matrix in row-major order */
export type Transform = number[];
/** A single plane represented as an inward unit normal and a signed distance */
export type ClipPlane = {
    normal?: Vector3d;
    distance?: number;
    invisible?: boolean;
    interior?: boolean;
};
/** Collection of ClipPlanes, often used for bounding regions of space. */
export type ClipPlaneSet = {
    planes: ClipPlane[];
};
/** A single clipping polygon defined by its outer ring positions. */
export type ClippingPolygon = {
    /** The points describing the outer ring of the clipping polygon. */
    positions: Vector3d[];
};
/** A cutout defined by one or more clipping polygons. */
export type PolygonSetCutout = {
    /** Discriminator indicating this uses polygon set geometry. */
    cutoutType: "polygonSet";
    /** Whether this cutout is active. If false, the cutout should be ignored during rendering. */
    enabled?: boolean;
    /** Clipping behavior: false = hide interior (area inside any polygon), true = hide exterior (area outside all polygons). */
    inverse?: boolean;
    /** Optional transform from local coordinate space to world coordinates. */
    transformFromClip?: Transform;
    /** Optional transform from world coordinates to local coordinate space. */
    transformToClip?: Transform;
    /** Array of clipping polygons. The cutout-level 'inverse' flag applies uniformly to all polygons. Per-polygon masking is not supported. */
    polygons: ClippingPolygon[];
};
/** A single clipping plane that defines a half-space for clipping geometry. */
export type ClippingPlane = {
    /** Inward unit normal vector. Points toward the region that should be kept when clipping. */
    normal: Vector3d;
    /** Signed distance from origin to plane. */
    distance: number;
};
/** A cutout defined by a single clipping plane. */
export type PlaneCutout = {
    /** Discriminator indicating this uses a single plane geometry. */
    cutoutType: "plane";
    /** Whether this cutout is active. If false, the cutout should be ignored during rendering. */
    enabled?: boolean;
    /** A single clipping plane that defines a half-space for clipping geometry. */
    plane: ClippingPlane;
};
/** An oriented box used for clipping geometry. */
export type ClippingBox = {
    /** Center position of the box. */
    center: Vector3d;
    /** Half-dimensions along each axis [halfWidth, halfHeight, halfDepth]. For a cube, all extents are equal. */
    halfExtents: Vector3d;
    /** Quaternion rotation defining box orientation. */
    rotation?: Quaternion;
};
/** A cutout defined by an oriented box. */
export type BoxCutout = {
    /** Discriminator indicating this uses box geometry. */
    cutoutType: "box";
    /** Whether this cutout is active. If false, the cutout should be ignored during rendering. */
    enabled?: boolean;
    /** Clipping behavior: false = hide interior, true = hide exterior. */
    inverse?: boolean;
    /** Optional transform from local coordinate space to world coordinates. */
    transformFromClip?: Transform;
    /** Optional transform from world coordinates to local coordinate space. */
    transformToClip?: Transform;
    /** An oriented box used for clipping geometry. */
    box: ClippingBox;
};
/**
 * An unsigned 32-bit integer in 0xTTBBGGRR format.
 * @deprecated Only used by deprecated ExpressionStyling types. Use {@link RgbColor} instead.
 */
export type ColorDef = number;
/** A color defined by red, green, blue, and optional alpha components. */
export type RgbColor = {
    /** Red component in the range [0, 255] */
    r: number;
    /** Green component in the range [0, 255] */
    g: number;
    /** Blue component in the range [0, 255] */
    b: number;
    /** Optional alpha component in the range [0, 255], where 0 is fully transparent and 255 is fully opaque */
    a?: number;
};
/** If defined and not equal to -1 (Invalid), the pixel pattern used to draw the edges. If undefined, edges are drawn using the element's line pattern. The patterns are, in order:
0: Code0 (Solid), 2155905152 (0x80808080): Code1 (1 lit pixel followed by 7 unlit pixels), 4177066232 (0xf8f8f8f8): Code2 (5 lit pixels followed by 3 unlit pixels), 4292935648 (0xffe0ffe0): Code3 (11 lit pixels followed by 5 unlit pixels), 4262526480 (0xfe10fe10): Code4 (7 lit pixels followed by 4 unlit pixels followed by 1 lit pixel followed by 1 lit pixel), 3772834016 (0xe0e0e0e0): Code5 (3 lit pixels followed by 5 unlit pixels), 4169726088 (0xf888f888): Code6 (5 lit pixels followed by 3 unlit followed by 1 lit followed by 3 unlit followed by 1 lit followed by 3 unlit), 4279828248 (0xff18ff18): Code7 (8 lit pixels followed by 3 unlit followed by 2 lit followed by 3 unlit), 3435973836 (0xcccccccc): HiddenLine (2 lit pixels followed by 2 unlit pixels - default style for drawing hidden edges), 1 (0x00000001): Invisible, -1: Invalid */
export type LinePixels = 0 | 2155905152 | 4177066232 | 4292935648 | 4262526480 | 3772834016 | 4169726088 | 4279828248 | 3435973836 | 1 | -1;
/** JSON representation of a hidden line style, which can be used to define how hidden lines are rendered in a view. */
export type HiddenLineStyle = {
    ovrColor?: boolean;
    color?: RgbColor;
    pattern?: LinePixels;
    width?: number;
};
/**
 * Symbology settings to apply to an attributed feature
 * @deprecated Only used by deprecated ExpressionStyling Category style type.
 */
export type FeatureSymbology = {
    lineColor: ColorDef;
    fillColor: ColorDef;
    weight: number;
    linePixels?: LinePixels;
};
/** A string literal or a JSEP expression that resolves to a string at runtime. */
export type StringOrExpression = RestrictedString | StyleExpression;
/** A numeric literal or a JSEP expression string that evaluates to a number. */
export type NumberOrExpression = number | StyleExpression;
/** An RGB(A) color object or a JSEP expression that evaluates to a color at runtime. */
export type ColorOrExpression = RgbColor | StyleExpression;
/** Symbol definition for rendering lines in geospatial features. */
export type LineSymbol = {
    type: "line-symbol";
    /** Color of the line. Can be a literal RGB(A) color or an expression. */
    color: ColorOrExpression;
    /** Width of the line in pixels. Can be a literal number or an expression. */
    width: NumberOrExpression;
};
/** Symbol definition for rendering filled areas in geospatial features. */
export type FillSymbol = {
    type: "fill-symbol";
    /** Fill color of the area. Can be a literal RGB(A) color or an expression. */
    color: ColorOrExpression;
    /** Optional outline symbol for the filled area. */
    outline?: LineSymbol;
};
/** Symbol definition for shape-based point feature markers. */
export type ShapeMarkerSymbol = {
    type: "shape-marker";
    /** Shape of the marker. */
    shape: "circle" | "square" | "triangle" | "diamond" | "cross" | "star" | "hexagon";
    /** Size of the marker in pixels. Can be a literal number or an expression. */
    size: NumberOrExpression;
    /** Fill symbology applied to the marker shape. */
    fill: FillSymbol;
};
/** Symbol definition for image-based point feature markers. */
export type ImageMarkerSymbol = {
    type: "image-marker";
    /** Image source: either a base64-encoded data URI (max 20KB, PNG/JPEG/SVG/WebP) or an HTTPS URL to a publicly hosted image. */
    url: Base64Image | HttpsUrl;
    /** Display width in pixels. If omitted, the image's intrinsic width is used. */
    width?: NumberOrExpression;
    /** Display height in pixels. If omitted, the image's intrinsic height is used. */
    height?: NumberOrExpression;
};
/** A symbol used to render a geospatial feature. Can be a line symbol, fill symbol, shape marker, or image marker. */
export type FeatureSymbol = LineSymbol | FillSymbol | ShapeMarkerSymbol | ImageMarkerSymbol;
/** Applies a single symbol uniformly to all features. */
export type SimpleSymbology = {
    type: "simple-symbology";
    /** The symbol applied uniformly to all features. */
    symbol: FeatureSymbol;
};
/** Styles features by matching an attribute value to a set of predefined categories. */
export type CategorySymbology = {
    type: "category-symbology";
    /** Attribute name or expression that resolves to the value used for category matching. */
    valueSource: StringOrExpression;
    /** Default symbol applied when no category value matches. */
    defaultSymbol: FeatureSymbol;
    /** Array of value-to-symbol mappings. Each entry defines a value to match and the symbol to apply. */
    categories: {
        /** The literal value to match against the valueSource result. */
        value: RestrictedString | number;
        /** Symbol to apply when this category matches. */
        symbol: FeatureSymbol;
        /** Optional human-readable name for this category. */
        displayName?: SafeString;
    }[];
};
/** Styles features by mapping a numeric attribute value to a set of defined ranges. */
export type IntervalSymbology = {
    type: "interval-symbology";
    /** Attribute name or expression that resolves to the numeric value used for interval matching. */
    valueSource: StringOrExpression;
    /** Default symbol applied when no interval range matches. */
    defaultSymbol: FeatureSymbol;
    /** Array of numeric range-to-symbol mappings. Each entry defines a value range and the symbol to apply. */
    intervals: {
        /** Upper bound of this interval. */
        maxValue: number;
        /** Optional lower bound of this interval. If omitted, the interval extends to negative infinity. */
        minValue?: number;
        /** Symbol to apply when the value falls within this interval. */
        symbol: FeatureSymbol;
        /** Optional human-readable name for this interval. */
        displayName?: SafeString;
    }[];
};
/**
 * All schema definitions and versions supported by the Scenes API.
 * Each schema can have multiple versions, each version defining its expected data structure.
 *
 * `{ [SchemaKind]: { [Version]: Definition } }`
 */
export interface ScenesApiSchemas {
    CameraAnimation: {
        /** Camera animation is defined by a series of 3D views with a timestamp. Interpolation of camera position is done by the application itself. */
        "1.0.0": {
            /** Timestamps sequence in seconds. */
            input: number[];
            /** Series of 3D views (and optional settings/schedules) for the animation. */
            output: {
                camera: SchemaData<"View3d", "1.0.0">;
                settings?: SchemaData<"UnrealAtmosphericStyling", "1.0.0">;
                schedule?: SchemaData<"ScheduleSimulation", "1.0.0">;
            }[];
        };
    };
    Cutout: {
        /** A polygon-defined area projected along the Z-axis on 3D tiles, used to exclude specific regions from rendering. It's primarily used to prevent visual conflicts between overlapping data layers. */
        "1.0.0": {
            /** The points describing the polygon. */
            polygon: Vector3d[];
            /** Transform from local to world. */
            transformFromClip?: Transform;
            /** Transform from world to local. */
            transformToClip?: Transform;
            /** Upper bound on Z. */
            zHigh?: number;
            /** Lower bound on Z. */
            zLow?: number;
            /** True if this shape is invisible. */
            invisible: boolean;
            /** True if this shape is a masking set. */
            mask: boolean;
            /** The union of convex regions. */
            clipPlanes?: {
                convexSets: ClipPlaneSet[];
            };
        };
        /** A cutout defines clipping regions to exclude specific areas from rendering. Supports single planes, polygon sets, and oriented boxes. */
        "2.0.0": {
            /** Ids of the scene objects this cutout applies to. Only the listed resources will be clipped. */
            appliesTo: Guid[];
            /** Clipping geometry definition. */
            cutout: PolygonSetCutout | PlaneCutout | BoxCutout;
        };
    };
    Layer: {
        /**
         * Layers act as organizational containers for scene content. They are not limited to contain specific data types.
         * Additional layer specific properties may be introduced in the future.
         */
        "1.0.0": Record<string, never>;
    };
    MaterialDecoration: {
        /** Reference to material mapping stored in the decoration service */
        "1.0.0": {
            /** Id of the material decoration for usage with the Decorations API */
            decorationId?: Guid;
        };
    };
    Movie: {
        /** A sequence of camera animations, or clips, which can be played independently or sequentially */
        "1.0.0": {
            /** Series of CameraAnimations in the movie. */
            animations: Guid[];
        };
    };
    Repository: {
        /** Reference to a single repository */
        "1.0.0": {
            /** Id of the iTwin this repository is associated with */
            iTwinId: Guid;
            /** Id of the repository. For Bentley repositories, this is the lowercase class. For external repositories, this is a unique identifier. */
            repositoryId: SafeString;
            /** Class of the repository, such as IndexedMedia or Forms */
            class: SupportedRepository;
            /** SubClass of the repository if applicable */
            subClass?: SafeString;
        };
    };
    RepositoryResource: {
        /** Reference to a single repository resource */
        "1.0.0": {
            /** Id of the iTwin this repository resource is associated with. Omit for global repository classes, e.g. Cesium." */
            iTwinId?: Guid;
            /** Id of the repository that contains this resource. For Bentley repositories like iModels, this is the lowercase class. For external repositories, this is a unique identifier. */
            repositoryId: SafeString;
            /** Id of the individual resource. Format depends on the repository (may be a GUID or another string identifier). */
            id: SafeString;
            /** Class of the repository containing this resource, e.g. iModels, RealityData, GeographicInformationSystem. */
            class: SafeString;
            /** SubClass of the repository type if applicable, e.g. WebMapTileService for GIS repositories. */
            subClass?: SafeString;
            /** Version of the resource, if the repository supports versioning, e.g. an iModel changesetId. If omitted, the latest resource version is used. Format depends on the repository. */
            version?: SafeString;
        };
    };
    View3d: {
        /** Representation of a 3D view */
        "1.0.0": {
            /** Location of the eye of the camera. */
            position: Vector3d;
            /** Whether the view is orthographic or perspective */
            isOrthographic: boolean;
            /** Aspect ratio of the view */
            aspectRatio: number;
            /** Direction the camera is pointing towards */
            direction: Vector3d;
            /** Defines 'up' direction relative to camera in the view */
            up: Vector3d;
            /** Near plane distance */
            near: number;
            /** Far plane distance */
            far: number;
            /** Angle of the field of view in radians for perspective views */
            fov?: number;
            /** Width of the frustum in meters for orthographic views */
            width?: number;
            /** Earth-Centered, Earth-Fixed transform */
            ecefTransform: Transform;
        };
    };
    GoogleTilesStyling: {
        /** Global setting to control styling options for Google tiles, such as rendering quality. */
        "1.0.0": {
            /** Quality of Google tiles rendering */
            quality: number;
            /** Matrix or vector used for adjusting the positioning of the tiles */
            adjustment?: number[];
        };
    };
    ITwinDisplayStyleOptions: {
        /** Global setting to control iModel styling when visualizing the scene in iTwin viewer applications. */
        "1.0.0": {
            /** Background color */
            backgroundColor?: RgbColor;
            /** Monochrome color */
            monochromeColor?: RgbColor;
            /** Monochrome mode. Flat = 0 and Scaled = 1 */
            monochromeMode?: 0 | 1;
            /** JSON representation of the view flags for the iTwin */
            iTwinViewFlags?: {
                noConstruct?: boolean;
                noDim?: boolean;
                noPattern?: boolean;
                noWeight?: boolean;
                noStyle?: boolean;
                noTransp?: boolean;
                noFill?: boolean;
                grid?: boolean;
                acs?: boolean;
                noTexture?: boolean;
                noMaterial?: boolean;
                noCameraLights?: boolean;
                noSourceLights?: boolean;
                noSolarLight?: boolean;
                visEdges?: boolean;
                hidEdges?: boolean;
                shadows?: boolean;
                clipVol?: boolean;
                monochrome?: boolean;
                renderMode?: 0 | 6 | 4 | 3;
                backgroundMap?: boolean;
                ambientOcclusion?: boolean;
                thematicDisplay?: boolean;
                wiremesh?: boolean;
                forceSurfaceDiscard?: boolean;
                noWhiteOnWhiteReversal?: boolean;
            };
            /** Describes symbology and behavior applied to a ClipVector when applied to a ViewState or ModelClipGroup */
            clipStyling?: {
                produceCutGeometry?: boolean;
                colorizeIntersection?: boolean;
                cutStyle?: {
                    viewflags?: {
                        renderMode?: 0 | 6 | 4 | 3;
                        dimensions?: boolean;
                        patterns?: boolean;
                        weights?: boolean;
                        styles?: boolean;
                        transparency?: boolean;
                        fill?: boolean;
                        textures?: boolean;
                        materials?: boolean;
                        acsTriad?: boolean;
                        grid?: boolean;
                        visibleEdges?: boolean;
                        hiddenEdges?: boolean;
                        shadows?: boolean;
                        clipVolume?: boolean;
                        constructions?: boolean;
                        monochrome?: boolean;
                        backgroundMap?: boolean;
                        ambientOcclusion?: boolean;
                        thematicDisplay?: boolean;
                        wiremesh?: boolean;
                        forceSurfaceDiscard?: boolean;
                        whiteOnWhiteReversal?: boolean;
                        lighting?: boolean;
                    };
                    hiddenLine?: {
                        visible?: HiddenLineStyle;
                        hidden?: HiddenLineStyle;
                        transThreshold?: number;
                    };
                    appearance?: {
                        rgb?: RgbColor;
                        lineRgb?: RgbColor;
                        weight?: number;
                        transparency?: number;
                        lineTransparency?: number;
                        linePixels?: LinePixels;
                        ignoresMaterial?: boolean;
                        nonLocatable?: boolean;
                        emphasized?: boolean;
                    };
                };
                insideColor?: RgbColor;
                outsideColor?: RgbColor;
                intersectionStyle?: {
                    color?: RgbColor;
                    width?: number;
                };
            };
            /** Controls how white-on-white reversal is applied to make white geometry more visible in the view.
       By default, pure white geometry is displayed as black instead if the backgroundColor is also pure white.
       These settings are only applied if the display style's whiteOnWhiteReversal flag is enabled. */
            whiteOnWhiteReversal?: {
                ignoreBackgroundColor?: boolean;
            };
        };
    };
    UnrealAtmosphericStyling: {
        /** Global setting to control unreal atmospheric styling when visualizing the scene in Carrot. */
        "1.0.0": {
            /** Atmospheric styling settings for the scene */
            atmosphere: {
                sunAzimuth: number;
                sunPitch: number;
                sunIntensity?: number;
                heliodonLongitude: number;
                heliodonLatitude: number;
                heliodonDate: DateTime;
                weather: number;
                windOrientation: number;
                windForce: number;
                fog: number;
                exposure: number;
                useHeliodon: boolean;
                HDRIImage?: SafeString;
                HDRIZRotation?: number;
            };
        };
    };
    ExpressionStyling: {
        /** Defines declarative styling options using expressions to control display properties based on element attributes. */
        "1.0.0": {
            /** Declarative styling options using expressions or categories to control display properties such as color, visibility, and appearance. Expressions are defined with JSEP (JavaScript Expression Parser) valid syntax. */
            stylingOptions?: {
                styleType: "Expression";
                defines?: {
                    [key: string]: ExpressionString;
                };
                show?: ExpressionOrConditions;
                color: ExpressionOrConditions;
                lineWeight?: ExpressionOrConditions;
                lineColor?: ExpressionOrConditions;
            } | {
                styleType: "Category";
                default: FeatureSymbology;
                rules: {
                    name: SafeString;
                    value: RestrictedString | number | boolean;
                    symbology: FeatureSymbology;
                }[];
            };
        };
    };
    GeospatialFeatureStyling: {
        /** Defines styling options for a specific geospatial features resource. */
        "1.0.0": {
            /** Defines how geospatial features are styled. Supports simple (uniform), category-based (attribute matching), and interval-based (numeric range) symbology. */
            featureSymbology: SimpleSymbology | CategorySymbology | IntervalSymbology;
        };
    };
    GISStyling: {
        /** Defines styling options for a specific GeographicInformationSystem (GIS) resource.*/
        "1.0.0": {
            /**
             * Transparency in the range [0.0, 1.0] where 0 indicates fully opaque and 1 indicates fully transparent.
             * @deprecated Use ResourceSettings.transparency instead.
             */
            transparency?: number;
        };
    };
    ScheduleSimulation: {
        /** 4D scheduling simulation for a specific iModel. */
        "1.0.0": {
            /** The Id of a RenderTimeline element containing a RenderSchedule.Script used to animate the schedule of a specific iModel */
            timelineId: Id64;
            /** The point in time expressed in seconds in the Unix epoch */
            timePoint: number;
        };
    };
    iModelVisibility: {
        /** Defines styling options for a specific iModel, including visible/hidden models and categories, rendering quality, and position adjustments. */
        "1.0.0": {
            /** Object maintaining visibility of categories in an iModel */
            categories: {
                shownList: CompressedId64Set;
                hiddenList: CompressedId64Set;
            };
            /** Object maintaining visibility of models in an iModel */
            models: {
                shownList: CompressedId64Set;
                hiddenList: CompressedId64Set;
            };
            /** Matrix used for adjusting the positioning of the iModel */
            adjustment?: number[];
            /** Quality of iModel rendering */
            quality?: number;
            /** Per-model category visibility overrides. Allows category visibility to be overridden in the context of individual models, taking precedence over the category's global visibility state. The override affects all subcategories within the overridden category. */
            perModelCategoryVisibility?: {
                /** Id of the model for which the override applies. */
                modelId: Id64;
                /** Id of the category whose visibility is overridden. */
                categoryId: Id64;
                /** Whether the category is visible in the context of the model. */
                visible: boolean;
            }[];
            /** Compressed Id64 Set of elements that should always be rendered, regardless of category and subcategory visibility. */
            alwaysDrawn?: CompressedId64Set;
            /** Compressed Id64 Set of elements that should never be rendered. This set takes precedence over the alwaysDrawn set. */
            neverDrawn?: CompressedId64Set;
        };
    };
    RealityDataStyling: {
        /** Defines styling options for a specific reality data resource. */
        "1.0.0": {
            /** If true, reality data will not be drawn when using Viewport.readPixels */
            nonLocatable?: boolean;
            /** The color of the Feature */
            rgb?: RgbColor;
            /**
             * Transparency in the range [0.0, 1.0] where 0 indicates fully opaque and 1 indicates fully transparent.
             * @deprecated Use ResourceSettings.transparency instead.
             */
            transparency?: number;
            /** Settings that control how a reality model - whether a ContextRealityModel or a persistent reality Model - is displayed within a Viewport. */
            displayProps?: {
                /** If the reality model's color is overridden with another color, a ratio in the range [0.0, 1.0] with which to mix the two colors together. A ratio of 0 uses only the reality model's color, a ratio of 1 uses only the override color, and a ratio of 0.5 mixes the two colors equally. */
                overrideColorRatio?: number;
                /** Settings that control how a point cloud reality model is displayed within a Viewport. */
                pointCloud?: {
                    /** The shape drawn for each point in the cloud. */
                    shape?: "square" | "round";
                    /** Specifies how the sizes of the individual points within a point cloud are computed. Pixel: Each point is an exact number of pixels in diameter. Voxel: Each point is the size of a 'voxel' in meters */
                    sizeMode?: "voxel" | "pixel";
                    /** Settings that control how points are displayed when 'sizeMode' is 'pixel'. */
                    pixelSettings?: {
                        /** The radius of each point in pixels The maximum size will vary based on the graphics hardware in use, but typically is limited to 32 or 64 pixels. */
                        size?: number;
                    };
                    /** Settings that control how points are displayed when 'sizeMode' is 'voxel'. */
                    voxelSettings?: {
                        /** Scale factor applied to the size of each point. */
                        scale?: number;
                        /** Minimum radius of each point in pixels. */
                        minPixelsPerVoxel?: number;
                        /** Maximum radius of each point in pixels. */
                        maxPixelsPerVoxel?: number;
                    };
                    /** Settings that control the Eye Dome Lighting (EDL) effect applied to a point cloud. */
                    eyeDome?: {
                        /** Off: EDL is not calculated. On: EDL is calculated using a single pass. Full: EDL is calculated with full algorithm including optional filtering. */
                        mode?: "off" | "on" | "full";
                        /** Increasing this value increases contrast on slopes and edges. */
                        strength?: number;
                        /** Increase the thickness of contours from eye dome lighting. */
                        radius?: number;
                        /** Flag for whether or not to apply filtering pass in the Eye Dome Lighting (EDL) effect. It only applies if edlMode is 'full'. */
                        filter?: number;
                        /** Weighting value in the range [0.0, 1.0] to apply to the full image when combining it with the half and quarter sized ones. */
                        mixWts1?: number;
                        /** Weighting value in the range [0.0, 1.0] to apply to the half sized image when combining it with the full and quarter sized ones. */
                        mixWts2?: number;
                        /** Weighting value in the range [0.0, 1.0] to apply to the quarter sized image when combining it with the full and half sized one. */
                        mixWts4?: number;
                    };
                };
            };
        };
    };
    ResourceSettings: {
        /** Defines display settings common to all repository resource types. Can be used alongside resource-specific styling schemas. */
        "1.0.0": {
            /** Transparency in the range [0.0, 1.0] where 0 indicates fully opaque and 1 indicates fully transparent. */
            transparency?: number;
            /** If true, selection is enabled for this resource, making it eligible to be included in selection results or used by selection-driven tools. If false, the resource remains visible but is not selectable. */
            selectionEnabled?: boolean;
        };
    };
}
/**
 * All schema kinds supported by the Scenes API
 */
export type SchemaKind = keyof ScenesApiSchemas;
/**
 * Available versions for a specific schema kind
 * @template K Schema kind to get versions for
 */
export type SchemaVersion<K extends SchemaKind> = keyof ScenesApiSchemas[K];
/**
 * Gets the data structure for a specific schema kind and version.
 * Core type that provides the actual schema interface.
 * @template K Schema kind (ex: 'Layer', 'View3d')
 * @template V Schema version (ex: '1.0.0')
 *
 * @example
 * ```typescript
 * // Get the data structure for View3d v1.0.0
 * type ViewData = SchemaData<'View3d', '1.0.0'>;
 * // Result: { position: vector3d; direction: vector3d; ... }
 *
 * // Type-safe usage
 * function processCamera(data: SchemaData<'CameraAnimation', '1.0.0'>) {
 *   data.input.forEach(timestamp => console.log(timestamp));
 *   data.output.forEach(frame => {
 *     console.log(frame.camera.position); // Fully typed!
 *   });
 * }
 * ```
 */
export type SchemaData<K extends SchemaKind, V extends SchemaVersion<K>> = ScenesApiSchemas[K][V];