core-backend.api.md

## API Report File for "@itwin/core-backend"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { AccessToken } from '@itwin/core-bentley';
import { Angle } from '@itwin/core-geometry';
import { AnnotationTextStyleProps } from '@itwin/core-common';
import { AuthorizationClient } from '@itwin/core-common';
import { AuxCoordSystem2dProps } from '@itwin/core-common';
import { AuxCoordSystem3dProps } from '@itwin/core-common';
import { AuxCoordSystemProps } from '@itwin/core-common';
import { AxisAlignedBox3d } from '@itwin/core-common';
import { Base64EncodedString } from '@itwin/core-common';
import { BaselineShift } from '@itwin/core-common';
import { BeDuration } from '@itwin/core-bentley';
import { BeEvent } from '@itwin/core-bentley';
import { BentleyError } from '@itwin/core-bentley';
import { BentleyStatus } from '@itwin/core-bentley';
import { BinaryImageSource } from '@itwin/core-common';
import { BRepGeometryCreate } from '@itwin/core-common';
import { BriefcaseConnectionProps } from '@itwin/core-common';
import { BriefcaseId } from '@itwin/core-common';
import { BriefcaseProps } from '@itwin/core-common';
import { CalloutProps } from '@itwin/core-common';
import { Camera } from '@itwin/core-common';
import { CatalogIModel } from '@itwin/core-common';
import { CategoryProps } from '@itwin/core-common';
import { CategorySelectorProps } from '@itwin/core-common';
import { ChangeData } from '@itwin/core-common';
import { ChangedElements } from '@itwin/core-common';
import { ChangedModels } from '@itwin/core-common';
import { ChangedValueState } from '@itwin/core-common';
import { ChangeOpCode } from '@itwin/core-common';
import { ChangesetFileProps } from '@itwin/core-common';
import { ChangesetHealthStats } from '@itwin/core-common';
import { ChangesetId } from '@itwin/core-common';
import { ChangesetIdWithIndex } from '@itwin/core-common';
import { ChangesetIndex } from '@itwin/core-common';
import { ChangesetIndexAndId } from '@itwin/core-common';
import { ChangesetIndexOrId } from '@itwin/core-common';
import { ChangesetProps } from '@itwin/core-common';
import { ChangesetRange } from '@itwin/core-common';
import { ClipVector } from '@itwin/core-geometry';
import { Code } from '@itwin/core-common';
import { CodeProps } from '@itwin/core-common';
import { CodeScopeProps } from '@itwin/core-common';
import { CodeScopeSpec } from '@itwin/core-common';
import { CodeSpec } from '@itwin/core-common';
import { CodeSpecProperties } from '@itwin/core-common';
import { ColorDef } from '@itwin/core-common';
import { ColorDefProps } from '@itwin/core-common';
import { ConcreteEntityTypes } from '@itwin/core-common';
import { Constructor } from '@itwin/core-bentley';
import { CreateEmptySnapshotIModelProps } from '@itwin/core-common';
import { CreateEmptyStandaloneIModelProps } from '@itwin/core-common';
import { CreateSnapshotIModelProps } from '@itwin/core-common';
import { DbChangeStage } from '@itwin/core-bentley';
import { DbConflictCause } from '@itwin/core-bentley';
import { DbConflictResolution } from '@itwin/core-bentley';
import { DbOpcode } from '@itwin/core-bentley';
import { DbResult } from '@itwin/core-bentley';
import { DbValueType } from '@itwin/core-bentley';
import { DefinitionElementProps } from '@itwin/core-common';
import { DisplayStyle3dProps } from '@itwin/core-common';
import { DisplayStyle3dSettings } from '@itwin/core-common';
import { DisplayStyle3dSettingsProps } from '@itwin/core-common';
import { DisplayStyleLoadProps } from '@itwin/core-common';
import { DisplayStyleProps } from '@itwin/core-common';
import { DisplayStyleSettings } from '@itwin/core-common';
import { DisplayStyleSettingsProps } from '@itwin/core-common';
import { DrawingProps } from '@itwin/core-common';
import { EcefLocation } from '@itwin/core-common';
import { ECSchemaProps } from '@itwin/core-common';
import { ECSqlReader } from '@itwin/core-common';
import { ECSqlValueType } from '@itwin/core-common';
import { ECVersion } from '@itwin/ecschema-metadata';
import { EditingScopeNotifications } from '@itwin/core-common';
import { ElementAlignedBox3d } from '@itwin/core-common';
import { ElementAspectProps } from '@itwin/core-common';
import { ElementGeometry } from '@itwin/core-common';
import { ElementGeometryCacheOperationRequestProps } from '@itwin/core-common';
import { ElementGeometryCacheRequestProps } from '@itwin/core-common';
import { ElementGeometryCacheResponseProps } from '@itwin/core-common';
import { ElementGeometryRequest } from '@itwin/core-common';
import { ElementGraphicsRequestProps } from '@itwin/core-common';
import { ElementLoadOptions } from '@itwin/core-common';
import { ElementLoadProps } from '@itwin/core-common';
import { ElementProps } from '@itwin/core-common';
import { EntityClass } from '@itwin/ecschema-metadata';
import { EntityIdAndClassIdIterable } from '@itwin/core-common';
import { EntityMetaData } from '@itwin/core-common';
import { EntityProps } from '@itwin/core-common';
import { EntityQueryParams } from '@itwin/core-common';
import { EntityReference } from '@itwin/core-common';
import { EntityReferenceSet } from '@itwin/core-common';
import { ExternalSourceAspectProps } from '@itwin/core-common';
import { ExternalSourceAttachmentProps } from '@itwin/core-common';
import { ExternalSourceAttachmentRole } from '@itwin/core-common';
import { ExternalSourceProps } from '@itwin/core-common';
import { FieldRun } from '@itwin/core-common';
import { FilePropertyProps } from '@itwin/core-common';
import { FontFace as FontFace_2 } from '@itwin/core-common';
import { FontFamilyDescriptor } from '@itwin/core-common';
import { FontFamilySelector } from '@itwin/core-common';
import { FontId } from '@itwin/core-common';
import { FontMap } from '@itwin/core-common';
import { FontProps } from '@itwin/core-common';
import { FontType } from '@itwin/core-common';
import { FractionRun } from '@itwin/core-common';
import { FunctionalElementProps } from '@itwin/core-common';
import { GeoCoordinatesRequestProps } from '@itwin/core-common';
import { GeoCoordinatesResponseProps } from '@itwin/core-common';
import { GeometricElement2dProps } from '@itwin/core-common';
import { GeometricElement3dProps } from '@itwin/core-common';
import { GeometricElementProps } from '@itwin/core-common';
import { GeometricModel2dProps } from '@itwin/core-common';
import { GeometricModel3dProps } from '@itwin/core-common';
import { GeometricModelProps } from '@itwin/core-common';
import { GeometryClass } from '@itwin/core-common';
import { GeometryContainmentRequestProps } from '@itwin/core-common';
import { GeometryContainmentResponseProps } from '@itwin/core-common';
import { GeometryParams } from '@itwin/core-common';
import { GeometryPartProps } from '@itwin/core-common';
import { GeometryStreamProps } from '@itwin/core-common';
import { GuidString } from '@itwin/core-bentley';
import { Id64Arg } from '@itwin/core-bentley';
import { Id64Array } from '@itwin/core-bentley';
import { Id64Set } from '@itwin/core-bentley';
import { Id64String } from '@itwin/core-bentley';
import { ImageBuffer } from '@itwin/core-common';
import { ImageBufferFormat } from '@itwin/core-common';
import { ImageSourceFormat } from '@itwin/core-common';
import { IModel } from '@itwin/core-common';
import { IModelConnectionProps } from '@itwin/core-common';
import { IModelCoordinatesRequestProps } from '@itwin/core-common';
import { IModelCoordinatesResponseProps } from '@itwin/core-common';
import { IModelError } from '@itwin/core-common';
import { IModelJsNative } from '@bentley/imodeljs-native';
import { IModelStatus } from '@itwin/core-bentley';
import { IModelTileTreeProps } from '@itwin/core-common';
import { IModelVersion } from '@itwin/core-common';
import { IndexedPolyface } from '@itwin/core-geometry';
import { InformationPartitionElementProps } from '@itwin/core-common';
import { InternetConnectivityStatus } from '@itwin/core-common';
import { IpcAppNotifications } from '@itwin/core-common';
import { IpcListener } from '@itwin/core-common';
import { IpcSocketBackend } from '@itwin/core-common';
import { IpcWebSocketBackend } from '@itwin/core-common';
import { ITwinError } from '@itwin/core-bentley';
import { JSONSchema } from '@itwin/core-bentley';
import { JSONSchemaType } from '@itwin/core-bentley';
import { JSONSchemaTypeName } from '@itwin/core-bentley';
import { LightLocationProps } from '@itwin/core-common';
import { LineLayoutResult } from '@itwin/core-common';
import { LinePixels } from '@itwin/core-common';
import { LineStyleProps } from '@itwin/core-common';
import { List } from '@itwin/core-common';
import { LocalBriefcaseProps } from '@itwin/core-common';
import { LocalDirName } from '@itwin/core-common';
import { LocalFileName } from '@itwin/core-common';
import { LockState as LockState_2 } from '@itwin/core-common';
import { LogLevel } from '@itwin/core-bentley';
import { Loop } from '@itwin/core-geometry';
import { LowAndHighXYZ } from '@itwin/core-geometry';
import { LRUMap } from '@itwin/core-bentley';
import { MarkRequired } from '@itwin/core-bentley';
import { MassPropertiesRequestProps } from '@itwin/core-common';
import { MassPropertiesResponseProps } from '@itwin/core-common';
import type { Metadata } from '@itwin/object-storage-core';
import { ModelExtentsProps } from '@itwin/core-common';
import { ModelGeometryChangesProps } from '@itwin/core-common';
import { ModelIdAndGeometryGuid } from '@itwin/core-common';
import { ModelProps } from '@itwin/core-common';
import { ModelSelectorProps } from '@itwin/core-common';
import { Mutable } from '@itwin/core-bentley';
import { NativeAppNotifications } from '@itwin/core-common';
import { NativeCloudSqlite } from '@bentley/imodeljs-native';
import { NativeLoggerCategory } from '@bentley/imodeljs-native';
import { NavigationBindingValue } from '@itwin/core-common';
import { NavigationValue } from '@itwin/core-common';
import { NormalMapProps } from '@itwin/core-common';
import { OpenBriefcaseProps } from '@itwin/core-common';
import { OpenCheckpointArgs } from '@itwin/core-common';
import { OpenMode } from '@itwin/core-bentley';
import { OpenSqliteArgs } from '@itwin/core-common';
import { Optional } from '@itwin/core-bentley';
import * as os from 'os';
import { OverriddenBy } from '@itwin/core-common';
import { Paragraph } from '@itwin/core-common';
import { Path } from '@itwin/core-geometry';
import { PhysicalElementProps } from '@itwin/core-common';
import { PhysicalTypeProps } from '@itwin/core-common';
import { PickAsyncMethods } from '@itwin/core-bentley';
import { PickMethods } from '@itwin/core-bentley';
import { Placement2d } from '@itwin/core-common';
import { Placement2dProps } from '@itwin/core-common';
import { Placement3d } from '@itwin/core-common';
import { Placement3dProps } from '@itwin/core-common';
import { Point2d } from '@itwin/core-geometry';
import { Point3d } from '@itwin/core-geometry';
import { Polyface } from '@itwin/core-geometry';
import { PolyfaceData } from '@itwin/core-geometry';
import { PolyfaceVisitor } from '@itwin/core-geometry';
import { ProjectInformation } from '@itwin/core-common';
import { ProjectInformationRecordProps } from '@itwin/core-common';
import { Property } from '@itwin/ecschema-metadata';
import { PropertyCallback } from '@itwin/core-common';
import { QueryBinder } from '@itwin/core-common';
import { QueryOptions } from '@itwin/core-common';
import { QueryRowFormat } from '@itwin/core-common';
import { Range2d } from '@itwin/core-geometry';
import { Range2dProps } from '@itwin/core-geometry';
import { Range3d } from '@itwin/core-geometry';
import { Rank } from '@itwin/core-common';
import { RelatedElement } from '@itwin/core-common';
import { RelatedElementProps } from '@itwin/core-common';
import { RelationshipClass } from '@itwin/ecschema-metadata';
import { RelationshipProps } from '@itwin/core-common';
import { RemoveFunction } from '@itwin/core-common';
import { RenderMaterialProps } from '@itwin/core-common';
import { RenderSchedule } from '@itwin/core-common';
import { RenderTimelineProps } from '@itwin/core-common';
import { RepositoryLinkProps } from '@itwin/core-common';
import { RequestNewBriefcaseProps } from '@itwin/core-common';
import { RgbFactorProps } from '@itwin/core-common';
import { RpcActivity } from '@itwin/core-common';
import { RpcInterfaceEndpoints } from '@itwin/core-common';
import { RscFontEncodingProps } from '@itwin/core-common';
import { Run } from '@itwin/core-common';
import { RunLayoutResult } from '@itwin/core-common';
import { SaveChangesArgs } from '@itwin/core-common';
import { SchemaContext } from '@itwin/ecschema-metadata';
import { SchemaItemKey } from '@itwin/ecschema-metadata';
import { SchemaKey as SchemaKey_2 } from '@itwin/ecschema-metadata';
import { SchemaState } from '@itwin/core-common';
import { SectionDrawingLocationProps } from '@itwin/core-common';
import { SectionDrawingProps } from '@itwin/core-common';
import { SectionType } from '@itwin/core-common';
import type { ServerStorage } from '@itwin/object-storage-core';
import { SessionProps } from '@itwin/core-common';
import { SheetBorderTemplateProps } from '@itwin/core-common';
import { SheetIndexEntryProps } from '@itwin/core-common';
import { SheetIndexReferenceProps } from '@itwin/core-common';
import { SheetInformation } from '@itwin/core-common';
import { SheetInformationAspectProps } from '@itwin/core-common';
import { SheetProps } from '@itwin/core-common';
import { SheetReferenceProps } from '@itwin/core-common';
import { SheetTemplateProps } from '@itwin/core-common';
import { SnapRequestProps } from '@itwin/core-common';
import { SnapResponseProps } from '@itwin/core-common';
import { SnapshotOpenOptions } from '@itwin/core-common';
import { SourceAndTarget } from '@itwin/core-common';
import { SpatialViewDefinitionProps } from '@itwin/core-common';
import { StandardViewIndex } from '@itwin/core-geometry';
import { StorageValue } from '@itwin/core-common';
import { SubCategoryAppearance } from '@itwin/core-common';
import { SubCategoryProps } from '@itwin/core-common';
import { SubCategoryResultRow } from '@itwin/core-common';
import { SubjectProps } from '@itwin/core-common';
import { SynchronizationConfigLinkProps } from '@itwin/core-common';
import { TabRun } from '@itwin/core-common';
import { TextAnnotation } from '@itwin/core-common';
import { TextAnnotation2dProps } from '@itwin/core-common';
import { TextAnnotation3dProps } from '@itwin/core-common';
import { TextAnnotationFrameShape } from '@itwin/core-common';
import { TextAnnotationLeader } from '@itwin/core-common';
import { TextAnnotationProps } from '@itwin/core-common';
import { TextBlock } from '@itwin/core-common';
import { TextBlockComponent } from '@itwin/core-common';
import { TextBlockGeometryProps } from '@itwin/core-common';
import { TextBlockLayoutResult } from '@itwin/core-common';
import { TextFrameStyleProps } from '@itwin/core-common';
import { TextRun } from '@itwin/core-common';
import { TextStyleSettings } from '@itwin/core-common';
import { TextStyleSettingsProps } from '@itwin/core-common';
import { TextureData } from '@itwin/core-common';
import { TextureLoadProps } from '@itwin/core-common';
import { TextureMapProps } from '@itwin/core-common';
import { TextureProps } from '@itwin/core-common';
import { ThumbnailFormatProps } from '@itwin/core-common';
import { ThumbnailProps } from '@itwin/core-common';
import type { TransferConfig } from '@itwin/object-storage-core';
import { Transform } from '@itwin/core-geometry';
import { TxnNotifications } from '@itwin/core-common';
import { TxnProps } from '@itwin/core-common';
import { TypeDefinition } from '@itwin/core-common';
import { TypeDefinitionElementProps } from '@itwin/core-common';
import { UpgradeOptions } from '@itwin/core-common';
import { UrlLinkProps } from '@itwin/core-common';
import { Vector3d } from '@itwin/core-geometry';
import { VersionedJSON } from '@itwin/core-common';
import { ViewAttachmentLabelProps } from '@itwin/core-common';
import { ViewAttachmentProps } from '@itwin/core-common';
import { ViewDefinition2dProps } from '@itwin/core-common';
import { ViewDefinition3dProps } from '@itwin/core-common';
import { ViewDefinitionProps } from '@itwin/core-common';
import { ViewDetails } from '@itwin/core-common';
import { ViewDetails3d } from '@itwin/core-common';
import { ViewFlags } from '@itwin/core-common';
import { ViewIdString } from '@itwin/core-common';
import { ViewQueryParams } from '@itwin/core-common';
import { ViewStateLoadProps } from '@itwin/core-common';
import { ViewStateProps } from '@itwin/core-common';
import { ViewStoreRpc } from '@itwin/core-common';
import { WritableXAndY } from '@itwin/core-geometry';
import * as ws from 'ws';
import { XAndY } from '@itwin/core-geometry';
import { XYAndZ } from '@itwin/core-geometry';
import { YawPitchRollAngles } from '@itwin/core-geometry';

// @public
export interface AcquireNewBriefcaseIdArg extends IModelIdArg {
    readonly briefcaseAlias?: string;
    readonly deviceName?: string;
}

// @public @preview
export class AnnotationElement2d extends GraphicalElement2d {
    protected constructor(props: GeometricElement2dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @beta
export class AnnotationTextStyle extends DefinitionElement {
    protected constructor(props: AnnotationTextStyleProps, iModel: IModelDb);
    // @internal (undocumented)
    static get className(): string;
    static create(iModelDb: IModelDb, arg: TextStyleCreateArgs): AnnotationTextStyle;
    static createCode(iModel: IModelDb, definitionModelId: CodeScopeProps, name: string): Code;
    protected static readonly _customHandledProps: CustomHandledProperty[];
    description?: string;
    static deserialize(props: DeserializeEntityArgs): AnnotationTextStyleProps;
    static fromJSON(props: AnnotationTextStyleProps, iModel: IModelDb): AnnotationTextStyle;
    // (undocumented)
    protected static onCloned(context: IModelElementCloneContext, srcProps: AnnotationTextStyleProps, dstProps: AnnotationTextStyleProps): Promise<void>;
    protected static onInsert(arg: OnElementPropsArg): void;
    protected static onUpdate(arg: OnElementPropsArg): void;
    static remapTextStyleId(sourceTextStyleId: Id64String, context: IModelElementCloneContext): Promise<Id64String>;
    static serialize(props: AnnotationTextStyleProps, iModel: IModelDb): ECSqlRow;
    settings: TextStyleSettings;
    toJSON(): AnnotationTextStyleProps;
}

// @beta
export type AnyDb = IModelDb | ECDb;

// @beta
export function appendFrameToBuilder(builder: ElementGeometry.Builder, frame: TextFrameStyleProps, range: Range2d, transform: Transform, geomParams: GeometryParams): boolean;

// @beta
export function appendLeadersToBuilder(builder: ElementGeometry.Builder, leaders: TextAnnotationLeader[], layout: TextBlockLayout, transform: Transform, params: GeometryParams, textStyleResolver: TextStyleResolver, scaleFactor: number): boolean;

// @beta
export function appendTextAnnotationGeometry(props: AppendTextAnnotationGeometryArgs): boolean;

// @beta
export interface AppendTextAnnotationGeometryArgs {
    annotationProps: TextAnnotationProps;
    builder: ElementGeometry.Builder;
    categoryId: Id64String;
    layout: TextBlockLayout;
    renderPriority?: RenderPriority;
    scaleFactor: number;
    subCategoryId?: Id64String;
    textStyleResolver: TextStyleResolver;
    wantDebugGeometry?: boolean;
}

// @public @preview
export abstract class AuxCoordSystem extends DefinitionElement {
    constructor(props: AuxCoordSystemProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    description?: string;
    // (undocumented)
    type?: number;
}

// @public @preview
export class AuxCoordSystem2d extends AuxCoordSystem {
    constructor(props: AuxCoordSystem2dProps, iModel: IModelDb);
    // (undocumented)
    angle?: number;
    // (undocumented)
    static get className(): string;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
    // (undocumented)
    origin?: Point2d;
}

// @public @preview
export class AuxCoordSystem3d extends AuxCoordSystem {
    constructor(props: AuxCoordSystem3dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
    // (undocumented)
    origin?: Point3d;
    // (undocumented)
    pitch?: number;
    // (undocumented)
    roll?: number;
    // (undocumented)
    yaw?: number;
}

// @public @preview
export class AuxCoordSystemSpatial extends AuxCoordSystem3d {
    // (undocumented)
    static get className(): string;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
}

// @beta
export interface AvailableCoordinateReferenceSystemProps {
    crsExtent: Range2dProps;
    deprecated: boolean;
    description: string;
    name: string;
}

// @beta (undocumented)
export interface AzureBlobStorageCredentials {
    // (undocumented)
    accessKey: string;
    // (undocumented)
    account: string;
    // (undocumented)
    baseUrl?: string;
}

// @public
export interface BackendHubAccess {
    acquireLocks: (arg: BriefcaseDbArg, locks: LockMap) => Promise<void>;
    acquireNewBriefcaseId: (arg: AcquireNewBriefcaseIdArg) => Promise<BriefcaseId>;
    createNewIModel: (arg: CreateNewIModelProps) => Promise<GuidString>;
    deleteIModel: (arg: IModelIdArg & ITwinIdArg) => Promise<void>;
    downloadChangeset: (arg: DownloadChangesetArg) => Promise<ChangesetFileProps>;
    downloadChangesets: (arg: DownloadChangesetRangeArg) => Promise<ChangesetFileProps[]>;
    getChangesetFromNamedVersion: (arg: IModelIdArg & {
        versionName: string;
    }) => Promise<ChangesetProps>;
    getChangesetFromVersion: (arg: IModelIdArg & {
        version: IModelVersion;
    }) => Promise<ChangesetProps>;
    getLatestChangeset: (arg: IModelIdArg) => Promise<ChangesetProps>;
    getMyBriefcaseIds: (arg: IModelIdArg) => Promise<BriefcaseId[]>;
    pushChangeset: (arg: IModelIdArg & {
        changesetProps: ChangesetFileProps;
    }) => Promise<ChangesetIndex>;
    queryAllLocks: (arg: BriefcaseDbArg) => Promise<LockProps[]>;
    queryChangeset: (arg: ChangesetArg) => Promise<ChangesetProps>;
    queryChangesets: (arg: ChangesetRangeArg) => Promise<ChangesetProps[]>;
    queryIModelByName: (arg: IModelNameArg) => Promise<GuidString | undefined>;
    queryV2Checkpoint: (arg: CheckpointProps) => Promise<V2CheckpointAccessProps | undefined>;
    releaseAllLocks: (arg: BriefcaseDbArg) => Promise<void>;
    releaseBriefcase: (arg: BriefcaseIdArg) => Promise<void>;
}

// @public
export enum BackendLoggerCategory {
    Authorization = "core-backend.Authorization",
    CodeSpecs = "core-backend.CodeSpecs",
    CustomViewState3dCreator = "core-backend.CustomViewState3dCreator",
    // @internal
    DevTools = "core-backend.DevTools",
    ECDb = "core-backend.ECDb",
    EventSink = "core-backend.EventSink",
    Functional = "core-backend.Functional",
    IModelDb = "core-backend.IModelDb",
    IModelHost = "core-backend.IModelHost",
    IModelTileRequestRpc = "core-backend.IModelTileRequestRpc",
    IModelTileStorage = "core-backend.IModelTileStorage",
    IModelTileUpload = "core-backend.IModelTileUpload",
    LinearReferencing = "core-backend.LinearReferencing",
    // @internal
    NativeApp = "core-backend.NativeApp",
    PromiseMemoizer = "core-backend.PromiseMemoizer",
    Relationship = "core-backend.Relationship",
    Schemas = "core-backend.Schemas",
    // @internal
    StashManager = "core-backend.StashManager",
    // @internal
    ViewStateHydrator = "core-backend.ViewStateHydrator",
    // @internal (undocumented)
    Workspace = "core-backend.Workspace"
}

// @public
export type BindParameter = number | string;

// @public
export class BisCoreSchema extends Schema {
    // @internal (undocumented)
    static registerSchema(): void;
    // (undocumented)
    static get schemaFilePath(): string;
    // (undocumented)
    static get schemaName(): string;
}

// @beta
export namespace BlobContainer {
    let service: BlobContainer.ContainerService | undefined;
    export interface AccessContainerProps extends UriAndId {
        // (undocumented)
        userToken: UserToken;
    }
    export type ContainerId = string;
    export interface ContainerService {
        create(props: CreateNewContainerProps): Promise<CreatedContainerProps>;
        delete(container: AccessContainerProps): Promise<void>;
        queryContainersMetadata(userToken: UserToken, args: QueryContainerProps): Promise<MetadataResponse[]>;
        queryMetadata(container: AccessContainerProps): Promise<Metadata>;
        queryScope(container: AccessContainerProps): Promise<Scope>;
        requestToken(props: RequestTokenProps): Promise<TokenProps>;
        updateJson(container: AccessContainerProps, json: SettingsContainer): Promise<void>;
    }
    export type ContainerToken = AccessToken;
    export interface CreatedContainerProps extends UriAndId {
        provider: Provider;
    }
    export interface CreateNewContainerProps {
        // @internal
        containerId?: ContainerId;
        metadata: Metadata;
        scope: Scope;
        userToken: UserToken;
    }
    export interface Metadata {
        containerType: string;
        description?: string;
        json?: SettingsContainer;
        label: string;
    }
    export interface MetadataResponse extends Metadata {
        // (undocumented)
        containerId: string;
    }
    export type Provider = "azure" | "google";
    export interface QueryContainerProps {
        containerType?: GuidString;
        iModelId?: GuidString;
        iTwinId: GuidString;
        label?: GuidString;
    }
    export type RequestAccessLevel = "write" | "read" | "admin" | "writeIfPossible";
    export interface RequestTokenProps extends Omit<AccessContainerProps, "baseUri"> {
        accessLevel?: RequestAccessLevel;
        durationSeconds?: number;
    }
    export interface Scope {
        iModelId?: Id64String;
        iTwinId: Id64String;
        ownerGuid?: GuidString;
    }
    export interface TokenProps {
        baseUri: string;
        expiration: Date;
        metadata: Metadata;
        provider: Provider;
        scope: Scope;
        token: ContainerToken;
    }
    export interface UriAndId {
        // (undocumented)
        baseUri: string;
        // (undocumented)
        containerId: ContainerId;
    }
    export type UserToken = AccessToken;
}

// @public
export class BriefcaseDb extends IModelDb {
    protected constructor(args: {
        nativeDb: IModelJsNative.DgnDb;
        key: string;
        openMode: OpenMode;
        briefcaseId: number;
    });
    // (undocumented)
    readonly briefcaseId: BriefcaseId;
    // @beta
    checkIfSchemaTxnExists(): boolean;
    // (undocumented)
    close(options?: CloseIModelArgs): void;
    // (undocumented)
    disableChangesetStatTracking(): Promise<void>;
    // @preview
    discardChanges(args?: {
        retainLocks?: true;
    }): Promise<void>;
    // (undocumented)
    enableChangesetStatTracking(): Promise<void>;
    // @internal
    executeWritable(func: () => Promise<void>): Promise<void>;
    // (undocumented)
    static findByKey(key: string): BriefcaseDb;
    // (undocumented)
    getAllChangesetHealthData(): Promise<ChangesetHealthStats[]>;
    get isBriefcase(): boolean;
    get iTwinId(): GuidString;
    // (undocumented)
    protected makeLockControl(): void;
    readonly onClosed: BeEvent<() => void>;
    // @alpha (undocumented)
    static readonly onCodeServiceCreated: BeEvent<(briefcase: BriefcaseDb) => void>;
    static readonly onOpen: BeEvent<(_args: OpenBriefcaseArgs) => void>;
    static readonly onOpened: BeEvent<(_iModelDb: BriefcaseDb, _args: OpenBriefcaseArgs) => void>;
    static open(args: OpenBriefcaseArgs): Promise<BriefcaseDb>;
    pullChanges(arg?: PullChangesArgs): Promise<void>;
    pushChanges(arg: PushChangesArgs): Promise<void>;
    revertAndPushChanges(arg: RevertChangesArgs): Promise<void>;
    // @internal (undocumented)
    get skipSyncSchemasOnPullAndPush(): boolean;
    toJSON(): BriefcaseConnectionProps;
    // (undocumented)
    static tryFindByKey(key: string): BriefcaseDb | undefined;
    readonly txns: TxnManager;
    static upgradeSchemas(briefcase: OpenBriefcaseArgs): Promise<void>;
    protected get useLockServer(): boolean;
}

// @public
export interface BriefcaseDbArg extends BriefcaseIdArg {
    // (undocumented)
    readonly changeset: ChangesetIdWithIndex;
}

// @public
export interface BriefcaseIdArg extends IModelIdArg {
    // (undocumented)
    readonly briefcaseId: BriefcaseId;
}

// @internal (undocumented)
export enum BriefcaseLocalValue {
    // (undocumented)
    NoLocking = "NoLocking",
    // (undocumented)
    StandaloneEdit = "StandaloneEdit"
}

// @public
export class BriefcaseManager {
    static acquireNewBriefcaseId(arg: AcquireNewBriefcaseIdArg): Promise<BriefcaseId>;
    static get cacheDir(): LocalDirName;
    // @internal
    static containsRestorePoint(db: BriefcaseDb, name: string): boolean;
    // @internal
    static createRestorePoint(db: BriefcaseDb, name: string): Promise<StashProps>;
    static deleteBriefcaseFiles(filePath: LocalFileName, accessToken?: AccessToken): Promise<void>;
    // @internal
    static deleteChangeSetsFromLocalDisk(iModelId: string): void;
    // @internal
    static deleteRebaseFolders(db: BriefcaseDb, checkIfEmpty?: boolean): void;
    // @internal
    static deleteTxnDataFolder(db: BriefcaseDb, txnId: string): void;
    // @internal
    static deleteTxnSchemaFolder(db: BriefcaseDb, txnId: string): void;
    static downloadBriefcase(arg: RequestNewBriefcaseArg): Promise<LocalBriefcaseProps>;
    // @beta
    static downloadChangeset(arg: DownloadChangesetArg): Promise<ChangesetFileProps>;
    // @beta
    static downloadChangesets(arg: DownloadChangesetRangeArg): Promise<ChangesetFileProps[]>;
    // @internal
    static dropRestorePoint(db: BriefcaseDb, name: string): void;
    // @internal
    static getBasePathForSemanticRebaseLocalFiles(db: BriefcaseDb): string;
    static getBriefcaseBasePath(iModelId: GuidString): LocalDirName;
    static getCachedBriefcases(iModelId?: GuidString): LocalBriefcaseProps[];
    // @internal (undocumented)
    static getChangeCachePathName(iModelId: GuidString): LocalFileName;
    // @internal (undocumented)
    static getChangedElementsPathName(iModelId: GuidString): LocalFileName;
    // @internal
    static getChangedInstancesDataForTxn(db: BriefcaseDb, txnId: string): InstancePatch[];
    // @internal (undocumented)
    static getChangeSetsPath(iModelId: GuidString): LocalDirName;
    static getFileName(briefcase: BriefcaseProps): LocalFileName;
    static getIModelPath(iModelId: GuidString): LocalDirName;
    static getLatestChangeset(arg: {
        iModelId: GuidString;
    }): Promise<ChangesetProps>;
    // @internal
    static getSchemasForTxn(db: BriefcaseDb, txnId: string): string[];
    static initialize(cacheRootDir: LocalDirName): void;
    static isValidBriefcaseId(id: BriefcaseId): boolean;
    // @internal (undocumented)
    static readonly PULL_MERGE_RESTORE_POINT_NAME = "$pull_merge_restore_point";
    // @internal
    static pullAndApplyChangesets(db: IModelDb, arg: PullChangesArgs): Promise<void>;
    // @internal
    static pullMergePush(db: BriefcaseDb, arg: PushChangesArgs): Promise<void>;
    static queryChangeset(arg: {
        iModelId: GuidString;
        changeset: ChangesetIndexOrId;
    }): Promise<ChangesetProps>;
    static queryChangesets(arg: {
        iModelId: GuidString;
        range: ChangesetRange;
    }): Promise<ChangesetProps[]>;
    static queryIModelByName(arg: IModelNameArg): Promise<GuidString | undefined>;
    static releaseBriefcase(accessToken: AccessToken, briefcase: BriefcaseProps): Promise<void>;
    // @internal
    static restorePoint(db: BriefcaseDb, name: string): Promise<void>;
    // @internal (undocumented)
    static revertTimelineChanges(db: IModelDb, arg: RevertChangesArgs): Promise<void>;
    // @internal
    static semanticRebaseDataFolderExists(db: BriefcaseDb, txnId: string): boolean;
    // @internal
    static semanticRebaseSchemaFolderExists(db: BriefcaseDb, txnId: string): boolean;
    // @internal
    static storeSchemasForSemanticRebase<T extends LocalFileName[] | string[]>(db: BriefcaseDb, txnId: string, schemaFileNames: T): void;
}

// @public
export abstract class Callout extends DetailingSymbol {
    constructor(props: CalloutProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @beta
export interface CatalogDb extends StandaloneDb {
    getInfo(): {
        manifest?: CatalogIModel.Manifest;
        version: string;
    };
    getManifest(): CatalogIModel.Manifest | undefined;
    getVersion(): string;
    isEditable(): this is EditableCatalogDb;
}

// @beta (undocumented)
export namespace CatalogDb {
    export function acquireWriteLock(args: {
        containerId: string;
        username: string;
    }): Promise<void>;
    export function createNewContainer(args: CatalogIModel.CreateNewContainerArgs): Promise<CatalogIModel.NewContainerProps>;
    export function createNewVersion(args: CatalogIModel.CreateNewVersionArgs): Promise<{
        oldDb: CatalogIModel.NameAndVersion;
        newDb: CatalogIModel.NameAndVersion;
    }>;
    export function openEditable(args: CatalogIModel.OpenArgs): Promise<EditableCatalogDb>;
    export function openReadonly(args: CatalogIModel.OpenArgs): Promise<CatalogDb>;
    export function releaseWriteLock(args: {
        containerId: string;
        abandon?: true;
    }): Promise<void>;
}

// @internal
export class CatalogIModelHandler extends IpcHandler implements CatalogIModel.IpcMethods {
    // (undocumented)
    acquireWriteLock(args: {
        containerId: string;
        username: string;
    }): Promise<void>;
    // (undocumented)
    get channelName(): CatalogIModel.IpcChannel;
    // (undocumented)
    createNewContainer(args: CatalogIModel.CreateNewContainerArgs): Promise<CatalogIModel.NewContainerProps>;
    // (undocumented)
    createNewVersion(args: CatalogIModel.CreateNewVersionArgs): Promise<{
        oldDb: CatalogIModel.NameAndVersion;
        newDb: CatalogIModel.NameAndVersion;
    }>;
    // (undocumented)
    getInfo(key: string): Promise<{
        manifest?: CatalogIModel.Manifest;
        version: string;
    }>;
    // (undocumented)
    openEditable(args: CatalogIModel.OpenArgs): Promise<IModelConnectionProps>;
    // (undocumented)
    openReadonly(args: CatalogIModel.OpenArgs): Promise<IModelConnectionProps>;
    // (undocumented)
    releaseWriteLock(args: {
        containerId: string;
        abandon?: true;
    }): Promise<void>;
    // (undocumented)
    updateCatalogManifest(key: string, manifest: CatalogIModel.Manifest): Promise<void>;
}

// @public @preview
export class Category extends DefinitionElement {
    protected constructor(props: CategoryProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // (undocumented)
    description?: string;
    // @beta
    static deserialize(props: DeserializeEntityArgs): CategoryProps;
    myDefaultSubCategoryId(): Id64String;
    // (undocumented)
    rank: Rank;
    // @beta
    static serialize(props: CategoryProps, iModel: IModelDb): ECSqlRow;
    setDefaultAppearance(props: SubCategoryAppearance.Props | SubCategoryAppearance): void;
    // (undocumented)
    toJSON(): CategoryProps;
}

// @public
export class CategoryOwnsSubCategories extends ElementOwnsChildElements {
    constructor(parentId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public @preview
export class CategorySelector extends DefinitionElement {
    protected constructor(props: CategorySelectorProps, iModel: IModelDb);
    categories: Id64String[];
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    static create(iModelDb: IModelDb, definitionModelId: Id64String, name: string, categories: Id64Array): CategorySelector;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // @beta
    static deserialize(props: DeserializeEntityArgs): CategorySelectorProps;
    static insert(iModelDb: IModelDb, definitionModelId: Id64String, name: string, categories: Id64Array): Id64String;
    // (undocumented)
    toJSON(): CategorySelectorProps;
}

// @beta
export interface ChangedECInstance {
    // (undocumented)
    $meta?: ChangeMetaData;
    // (undocumented)
    [key: string]: any;
    // (undocumented)
    ECClassId?: Id64String;
    // (undocumented)
    ECInstanceId: Id64String;
}

// @internal
export class ChangedElementsDb implements Disposable {
    // (undocumented)
    [Symbol.dispose](): void;
    constructor();
    // (undocumented)
    cleanCaches(): void;
    closeDb(): void;
    static createDb(briefcase: IModelDb, pathName: string): ChangedElementsDb;
    getChangeData(startChangesetId: string, endChangesetId: string): ChangeData | undefined;
    getChangedElements(startChangesetId: string, endChangesetId: string): ChangedElements | undefined;
    getChangedModels(startChangesetId: string, endChangesetId: string): ChangedModels | undefined;
    get isOpen(): boolean;
    isProcessed(changesetId: string): boolean;
    // (undocumented)
    get nativeDb(): IModelJsNative.ChangedElementsECDb;
    static openDb(pathName: string, openMode?: ECDbOpenMode): ChangedElementsDb;
    processChangesets(accessToken: AccessToken, briefcase: IModelDb, options: ProcessChangesetOptions): Promise<DbResult>;
    processChangesetsAndRoll(accessToken: AccessToken, briefcase: IModelDb, options: ProcessChangesetOptions): Promise<DbResult>;
}

// @beta
export interface ChangeFormatArgs {
    includeNullColumns?: true;
    includeOpCode?: true;
    includePrimaryKeyInUpdateNew?: true;
    includeStage?: true;
    includeTableName?: true;
}

// @beta
export interface ChangeInstanceKey {
    changeType: "inserted" | "updated" | "deleted";
    classFullName: string;
    id: Id64String;
}

// @beta
export interface ChangeMetaData {
    changeIndexes: number[];
    classFullName?: string;
    fallbackClassId?: Id64String;
    op: SqliteChangeOp;
    stage: SqliteValueStage;
    tables: string[];
}

// @public
export interface ChangesetArg extends IModelIdArg {
    // (undocumented)
    readonly changeset: ChangesetIndexOrId;
}

// @beta
export class ChangesetECAdaptor implements Disposable {
    [Symbol.dispose](): void;
    constructor(reader: SqliteChangesetReader, disableMetaData?: boolean);
    acceptClass(classFullName: string): ChangesetECAdaptor;
    acceptOp(op: SqliteChangeOp): ChangesetECAdaptor;
    acceptTable(table: string): ChangesetECAdaptor;
    close(): void;
    readonly debugFlags: {
        replaceBlobWithEllipsis: boolean;
        replaceGeomWithEllipsis: boolean;
        replaceGuidWithEllipsis: boolean;
    };
    deleted?: ChangedECInstance;
    // (undocumented)
    readonly disableMetaData: boolean;
    inserted?: ChangedECInstance;
    get isDeleted(): boolean;
    isECTable(tableName: string): boolean;
    get isInserted(): boolean;
    get isUpdated(): boolean;
    get op(): SqliteChangeOp;
    // (undocumented)
    readonly reader: SqliteChangesetReader;
    step(): boolean;
}

// @internal (undocumented)
export interface ChangesetIndexArg extends IModelIdArg {
    // (undocumented)
    readonly changeset: ChangesetIdWithIndex;
}

// @public
export interface ChangesetRangeArg extends IModelIdArg {
    readonly range?: ChangesetRange;
}

// @beta
export interface ChangeSummary {
    // (undocumented)
    changeSet: {
        wsgId: GuidString;
        parentWsgId: GuidString;
        description: string;
        pushDate: string;
        userCreated: GuidString;
    };
    // (undocumented)
    id: Id64String;
}

// @beta
export class ChangeSummaryManager {
    static attachChangeCache(iModel: IModelDb): void;
    static buildPropertyValueChangesECSql(iModel: IModelDb, instanceChangeInfo: {
        id: Id64String;
        summaryId: Id64String;
        changedInstance: {
            id: Id64String;
            className: string;
        };
    }, changedValueState: ChangedValueState, changedPropertyNames?: string[]): string;
    static createChangeSummaries(args: CreateChangeSummaryArgs): Promise<Id64String[]>;
    static createChangeSummary(accessToken: AccessToken, iModel: BriefcaseDb): Promise<Id64String>;
    static detachChangeCache(iModel: IModelDb): void;
    static getChangedPropertyValueNames(iModel: IModelDb, instanceChangeId: Id64String): string[];
    static isChangeCacheAttached(iModel: IModelDb): boolean;
    static queryChangeSummary(iModel: BriefcaseDb, changeSummaryId: Id64String): ChangeSummary;
    static queryInstanceChange(iModel: BriefcaseDb, instanceChangeId: Id64String): InstanceChange;
}

// @beta
export interface ChannelControl {
    // @internal (undocumented)
    readonly [_implementationProhibited]: unknown;
    // @internal (undocumented)
    [_verifyChannel]: (modelId: Id64String) => void;
    addAllowedChannel(channelKey: ChannelKey): void;
    getChannelKey(elementId: Id64String): ChannelKey;
    insertChannelSubject(args: {
        subjectName: string;
        channelKey: ChannelKey;
        parentSubjectId?: Id64String;
        description?: string;
    }): Id64String;
    makeChannelRoot(args: {
        elementId: Id64String;
        channelKey: ChannelKey;
    }): void;
    queryChannelRoot(channelKey: ChannelKey): Id64String | undefined;
    removeAllowedChannel(channelKey: ChannelKey): void;
    upgradeChannel(options: ChannelUpgradeOptions, iModel: IModelDb, data?: any): Promise<void>;
}

// @beta (undocumented)
export namespace ChannelControl {
    const sharedChannelName = "shared";
}

// @beta
export type ChannelKey = string;

// @public @preview (undocumented)
export class ChannelRootAspect extends ElementUniqueAspect {
    // (undocumented)
    static get className(): string;
    // @deprecated
    static insert(iModel: IModelDb, ownerId: Id64String, channelName: string): void;
}

// @beta
export interface ChannelUpgradeContext<T = any> {
    // (undocumented)
    channelKey: string;
    data?: T;
    // (undocumented)
    fromVersion: string;
    // (undocumented)
    iModel: IModelDb;
    // (undocumented)
    toVersion: string;
}

// @beta
export interface ChannelUpgradeOptions<T = any> {
    // (undocumented)
    callback: (context: ChannelUpgradeContext<T>) => Promise<void>;
    // (undocumented)
    channelKey: string;
    // (undocumented)
    fromVersion: string;
    // (undocumented)
    toVersion: string;
}

// @internal (undocumented)
export class CheckpointManager {
    static downloadCheckpoint(request: DownloadRequest): Promise<void>;
    // (undocumented)
    static getKey(checkpoint: CheckpointProps): string;
    // (undocumented)
    static readonly onDownloadV2: BeEvent<(job: DownloadJob) => void>;
    // (undocumented)
    static toCheckpointProps(args: OpenCheckpointArgs): Promise<CheckpointProps>;
    // (undocumented)
    static updateToRequestedVersion(request: DownloadRequest): Promise<void>;
    static validateCheckpointGuids(checkpoint: CheckpointProps, snapshotDb: SnapshotDb): void;
    // (undocumented)
    static verifyCheckpoint(checkpoint: CheckpointProps, fileName: LocalFileName): boolean;
}

// @public
export interface CheckpointProps extends TokenArg {
    readonly allowPreceding?: boolean;
    readonly changeset: ChangesetIdWithIndex;
    // (undocumented)
    readonly expectV2?: boolean;
    readonly iModelId: GuidString;
    readonly iTwinId: GuidString;
    readonly reattachSafetySeconds?: number;
}

// @public
export class ClassRegistry {
    static findRegisteredClass(classFullName: string): typeof Entity | undefined;
    static getClass(classFullName: string, iModel: IModelDb): typeof Entity;
    // @internal
    static getRootEntity(iModel: IModelDb, ecTypeQualifier: string): string;
    // @internal (undocumented)
    static isNotFoundError(err: any): boolean;
    // @internal (undocumented)
    static makeMetaDataNotFoundError(className: string): IModelError;
    static register(entityClass: typeof Entity, schema: typeof Schema): void;
    static registerModule(moduleObj: any, schema: typeof Schema): void;
    // @internal
    static unregisterClass(classFullName: string): boolean;
    // @internal
    static unregisterClassesFrom(schema: typeof Schema): void;
}

// @beta
export interface ClearCachesOptions {
    instanceCachesOnly?: boolean;
}

// @public
export interface CloseIModelArgs {
    optimize?: boolean;
}

// @public
export interface CloudContainerArgs {
    // @internal (undocumented)
    container?: CloudSqlite.CloudContainer;
}

// @beta
export namespace CloudSqlite {
    export function acquireWriteLock(args: {
        user: string;
        container: CloudContainer;
        busyHandler?: WriteLockBusyHandler;
    }): Promise<void>;
    export function addHiddenProperty<T>(o: T, p: PropertyKey, value?: any): T;
    // @internal
    export interface BcvHttpLog {
        readonly endTime: string | undefined;
        readonly httpcode: number;
        readonly id: number;
        readonly logId: string;
        readonly logmsg: string;
        readonly method: string;
        readonly startTime: string;
        readonly uri: string;
    }
    // @internal
    export interface BcvHttpLogFilterOptions {
        finishedAtOrAfterTime?: string;
        showOnlyFinished?: boolean;
        startFromId?: number;
    }
    // @internal
    export interface BcvStats {
        readonly activeClients?: string;
        readonly attachedContainers?: string;
        readonly lockedCacheslots: string;
        readonly memoryClientArray?: string;
        readonly memoryClientManifest?: string;
        readonly memoryHighwater?: string;
        readonly memoryManifest?: string;
        readonly memoryUsed?: string;
        readonly ongoingPrefetches?: string;
        readonly populatedCacheslots: string;
        readonly totalCacheslots: string;
        readonly totalClients?: string;
    }
    // @internal
    export interface BcvStatsFilterOptions {
        addClientInformation?: boolean;
    }
    export interface CachedDbProps {
        readonly dirtyBlocks: number;
        readonly localBlocks: number;
        readonly nClient: number;
        readonly nPrefetch: number;
        readonly state: "" | "copied" | "deleted";
        readonly totalBlocks: number;
        readonly transactions: boolean;
    }
    export interface CacheProps extends CloudHttpProps {
        cacheSize?: string;
        curlDiagnostics?: boolean;
        name: string;
        rootDir: string;
    }
    export function cleanDeletedBlocks(container: CloudContainer, options: CleanDeletedBlocksOptions): Promise<void>;
    // (undocumented)
    export interface CleanDeletedBlocksOptions {
        debugLogging?: boolean;
        findOrphanedBlocks?: boolean;
        nSeconds?: number;
        onProgress?: (nDeleted: number, nTotalToDelete: number) => Promise<number>;
    }
    export interface CloudCache {
        // @internal
        destroy(): void;
        get guid(): GuidString;
        get isDaemon(): boolean;
        get name(): string;
        get rootDir(): LocalDirName;
        setLogMask(mask: number): void;
    }
    export class CloudCaches {
        // @internal
        static destroy(): void;
        // @internal (undocumented)
        static dropCache(cacheName: string): CloudCache | undefined;
        static findCache(cacheName: string): CloudCache | undefined;
        static getCache(args: CreateCloudCacheArg): CloudCache;
    }
    export interface CloudContainer {
        abandonChanges(): void;
        get accessToken(): string;
        set accessToken(val: string);
        acquireWriteLock(user: string): void;
        get alias(): string;
        get baseUri(): string;
        get blockSize(): number;
        // (undocumented)
        readonly cache?: CloudCache;
        checkForChanges(): void;
        clearWriteLock(): void;
        connect(cache: CloudCache): void;
        get containerId(): string;
        copyDatabase(dbName: string, toAlias: string): Promise<void>;
        deleteDatabase(dbName: string): Promise<void>;
        disconnect(args?: {
            detach?: boolean;
        }): void;
        get garbageBlocks(): number;
        get hasLocalChanges(): boolean;
        get hasWriteLock(): boolean;
        initializeContainer(args: {
            checksumBlockNames?: boolean;
            blockSize: number;
        }): void;
        get isConnected(): boolean;
        get isPublic(): boolean;
        get isWriteable(): boolean;
        get logId(): string;
        // (undocumented)
        onConnect?: (container: CloudContainer, cache: CloudCache) => void;
        // (undocumented)
        onConnected?: (container: CloudContainer) => void;
        // (undocumented)
        onDisconnect?: (container: CloudContainer, detach: boolean) => void;
        // (undocumented)
        onDisconnected?: (container: CloudContainer, detach: boolean) => void;
        // @internal
        queryBcvStats(filterOptions?: BcvStatsFilterOptions): CloudSqlite.BcvStats;
        queryDatabase(dbName: string): CachedDbProps | undefined;
        queryDatabaseHash(dbName: string): string;
        queryDatabases(globArg?: string): string[];
        // @internal
        queryHttpLog(filterOptions?: BcvHttpLogFilterOptions): CloudSqlite.BcvHttpLog[];
        releaseWriteLock(): void;
        get storageType(): string;
        uploadChanges(): Promise<void>;
        get writeLockExpires(): string;
    }
    // (undocumented)
    export interface CloudHttpProps {
        nRequests?: number;
    }
    export interface CloudPrefetch {
        cancel(): void;
        // (undocumented)
        readonly cloudContainer: CloudContainer;
        // (undocumented)
        readonly dbName: string;
        promise: Promise<boolean>;
    }
    export interface ContainerAccessProps extends ContainerProps {
        accessToken: string;
        readonly alias?: string;
        readonly lockExpireSeconds?: number;
        readonly logId?: string;
        readonly secure?: boolean;
        readonly tokenRefreshSeconds?: number;
        readonly writeable?: boolean;
    }
    // (undocumented)
    export interface ContainerProps {
        accessToken?: string;
        readonly baseUri: string;
        readonly containerId: string;
        readonly isPublic?: boolean;
        readonly storageType: "azure" | "google";
    }
    export interface CreateCloudCacheArg {
        cacheDir?: string;
        cacheName: string;
        cacheSize?: string;
    }
    export function createCloudContainer(args: ContainerAccessProps & {
        accessLevel?: BlobContainer.RequestAccessLevel;
        tokenFn?: (args: RequestTokenArgs) => Promise<AccessToken>;
    }): CloudContainer;
    // (undocumented)
    export function createNewDbVersion(container: CloudContainer, args: CreateNewDbVersionArgs): Promise<{
        oldDb: DbNameAndVersion;
        newDb: DbNameAndVersion;
    }>;
    export interface CreateNewDbVersionArgs {
        // (undocumented)
        readonly fromDb: DbNameAndVersion;
        readonly identifier?: string;
        readonly versionType: SemverIncrement;
    }
    export class DbAccess<DbType extends VersionedSqliteDb, ReadMethods = DbType, WriteMethods = DbType> {
        constructor(args: {
            dbType: Constructor<DbType>;
            props: ContainerAccessProps;
            dbName: string;
        });
        // (undocumented)
        protected static _cacheName: string;
        close(): void;
        closeDb(): void;
        // (undocumented)
        protected _cloudDb: DbType;
        get container(): CloudContainer;
        // (undocumented)
        protected _container: CloudContainer;
        protected static createBlobContainer(args: Omit<BlobContainer.CreateNewContainerProps, "userToken">): Promise<CloudSqlite.ContainerProps>;
        readonly dbName: string;
        // @internal (undocumented)
        getCache(): CloudCache;
        // @internal (undocumented)
        static getCacheForClass(): CloudCache;
        // @internal (undocumented)
        getCloudDb(): DbType;
        protected static _initializeDb(args: {
            dbType: typeof VersionedSqliteDb;
            props: ContainerProps;
            dbName: string;
            blockSize?: "64K" | "4M";
        }): Promise<void>;
        readonly lockParams: ObtainLockParams;
        openForRead(): DbType;
        get reader(): PickMethods<ReadMethods>;
        get sasToken(): AccessToken;
        set sasToken(token: AccessToken);
        // @internal
        setCache(cache: CloudCache): void;
        startPrefetch(): CloudPrefetch;
        synchronizeWithCloud(): void;
        withLockedDb<T>(args: {
            operationName: string;
            openMode?: OpenMode;
            user?: string;
        }, operation: () => Promise<T>): Promise<T>;
        get writeLocker(): PickAsyncMethods<WriteMethods>;
    }
    export type DbFullName = string;
    export type DbName = string;
    export interface DbNameAndVersion {
        readonly dbName: DbName;
        readonly version?: DbVersionRange;
    }
    export interface DbNameProp {
        dbName: DbFullName;
    }
    export type DbVersion = string;
    export type DbVersionRange = string;
    export function downloadDb(container: CloudContainer, props: TransferDbProps): Promise<void>;
    // (undocumented)
    export function getBlobService(): BlobContainer.ContainerService;
    // (undocumented)
    export function getWriteLockHeldBy(container: CloudContainer): string | undefined;
    // (undocumented)
    export function isSemverEditable(dbFullName: string, container: CloudContainer): boolean | readonly (string | number)[];
    // (undocumented)
    export function isSemverPrerelease(version: string): true | readonly (string | number)[] | null;
    // (undocumented)
    export interface LoadProps extends DbNameAndVersion {
        // (undocumented)
        readonly container: CloudContainer;
        readonly includePrerelease?: boolean;
        readonly prefetch?: boolean;
    }
    // @internal (undocumented)
    export interface LockAndOpenArgs extends SQLiteDb.WithOpenDbArgs {
        busyHandler?: WriteLockBusyHandler;
        container: CloudContainer;
        dbName: string;
        openMode?: OpenMode;
        user: string;
    }
    export enum LoggingMask {
        AddToDelete = 4,
        All = 255,
        DirtyBlocks = 2,
        HTTP = 1,
        LifecycleEvents = 8,
        None = 0
    }
    export function makeSemverName(dbName: DbName, version?: DbVersion): DbName;
    // (undocumented)
    export function noLeadingOrTrailingSpaces(name: string, msg: string): void;
    export interface ObtainLockParams {
        nRetries: number;
        onFailure?: WriteLockBusyHandler;
        retryDelayMs: number;
        user?: string;
    }
    export function parseDbFileName(dbFileName: DbFullName): {
        dbName: DbName;
        version: DbVersion;
    };
    // (undocumented)
    export interface PrefetchProps extends CloudHttpProps {
        minRequests?: number;
        timeout?: number;
    }
    export function querySemverMatch(props: LoadProps): DbFullName;
    export function releaseWriteLock(container: CloudContainer): void;
    export function requestToken(args: RequestTokenArgs): Promise<AccessToken>;
    // (undocumented)
    export type RequestTokenArgs = Optional<BlobContainer.RequestTokenProps, "userToken">;
    export type SemverIncrement = "major" | "minor" | "patch" | "premajor" | "preminor" | "prepatch" | "prerelease";
    export function startCloudPrefetch(container: CloudContainer, dbName: string, args?: PrefetchProps): CloudPrefetch;
    // @internal (undocumented)
    export function transferDb(direction: TransferDirection, container: CloudContainer, props: TransferDbProps): Promise<void>;
    // (undocumented)
    export interface TransferDbProps extends DbNameProp, TransferProgress, CloudHttpProps {
        localFileName: LocalFileName;
    }
    // (undocumented)
    export type TransferDirection = "upload" | "download";
    // (undocumented)
    export interface TransferProgress {
        onProgress?: (loaded: number, total: number) => number;
    }
    export function uploadDb(container: CloudContainer, props: TransferDbProps): Promise<void>;
    // (undocumented)
    export function validateDbName(dbName: DbName): void;
    // (undocumented)
    export function validateDbVersion(version?: DbVersion): string;
    export function withWriteLock<T>(args: {
        user: string;
        container: CloudContainer;
        busyHandler?: WriteLockBusyHandler;
    }, operation: () => Promise<T>): Promise<T>;
    export type WriteLockBusyHandler = (lockedBy: string, expires: string) => Promise<void | "stop">;
    export {};
}

// @alpha
export interface CodeService {
    readonly appParams: CodeService.AuthorAndOrigin;
    // @internal (undocumented)
    close: () => void;
    readonly externalCodes?: CloudSqlite.DbAccess<CodeService.CodesDb, CodeService.ReadMethods, CodeService.WriteMethods>;
    // (undocumented)
    initialize(iModel: IModelDb): Promise<void>;
    readonly internalCodes?: CloudSqlite.DbAccess<CodeService.InternalCodes, CodeService.InternalReadMethods, CodeService.InternalWriteMethods>;
    verifyCode(props: CodeService.ElementCodeProps): void;
}

// @alpha (undocumented)
export namespace CodeService {
    export interface AuthorAndOrigin {
        readonly author: Mutable<NameAndJson>;
        readonly origin: Mutable<NameAndJson>;
    }
    export type AuthorName = string;
    // @internal (undocumented)
    export interface BisCodeSpecIndexProps {
        // (undocumented)
        id?: number;
        // (undocumented)
        name: string;
        // (undocumented)
        props: string;
    }
    export interface CodeEntry {
        readonly author?: AuthorName;
        readonly guid: CodeGuid;
        readonly json?: SettingsContainer;
        readonly origin: CodeOriginName;
        readonly scopeGuid: ScopeGuid;
        readonly specName: CodeSpecName;
        readonly state?: CodeState;
        readonly value: CodeValue;
    }
    export interface CodeFilter extends ValueFilter {
        readonly origin?: CodeOriginName;
        readonly scopeGuid?: ScopeGuid;
        readonly specName?: CodeSpecName;
    }
    export type CodeGuid = GuidString;
    let // @internal (undocumented)
    createForIModel: ((db: IModelDb) => Promise<CodeService>) | undefined;
    export interface CodeGuidStateJson {
        readonly guid: CodeGuid;
        readonly json?: SettingsContainer;
        readonly state?: CodeState;
    }
    export type CodeIteration = (guid: GuidString) => IterationReturn;
    export type CodeOriginName = string;
    // (undocumented)
    export type CodesDb = VersionedSqliteDb & WriteMethods & ReadMethods;
    export interface CodeSequence {
        getFirstValue(): CodeValue;
        getLastValue(): CodeValue;
        getNextValue(code: CodeValue): CodeValue;
        isValidCode(code: CodeValue): boolean;
        get sequenceName(): string;
    }
    export type CodeSpecName = string;
    export type CodeState = number;
    export type CodeValue = string;
    export interface ElementCodeProps {
        readonly iModel: IModelDb;
        readonly props: {
            readonly code: CodeProps;
            federationGuid?: GuidString;
        };
    }
    export class Error extends BentleyError {
        // @internal
        constructor(errorId: ErrorId, errNum: number, message: string, problems?: ReserveProblem[] | UpdateProblem[]);
        readonly errorId: ErrorId;
        readonly problems?: ReserveProblem[] | UpdateProblem[];
    }
    export type ErrorId = "BadIndexProps" | "CorruptIModel" | "CorruptIndex" | "DuplicateValue" | "GuidIsInUse" | "GuidMismatch" | "IllegalValue" | "InconsistentIModels" | "IndexReadonly" | "InvalidCodeScope" | "InvalidGuid" | "InvalidSequence" | "MissingCode" | "MissingGuid" | "MissingInput" | "MissingSpec" | "NoCodeIndex" | "NotAuthorized" | "SequenceFull" | "ReserveErrors" | "SequenceNotFound" | "SqlLogicError" | "UpdateErrors" | "ValueIsInUse" | "WrongVersion";
    // @internal (undocumented)
    export interface FontIndexProps {
        // (undocumented)
        fontName: string;
        // (undocumented)
        fontType: FontType;
        // (undocumented)
        id?: number;
    }
    export function getSequence(name: string): CodeSequence;
    // (undocumented)
    export type InternalCodes = CodesDb & InternalWriteMethods & InternalReadMethods;
    // (undocumented)
    export interface InternalReadMethods extends ReadMethods {
        // @internal (undocumented)
        verifyBisCodeSpec(spec: CodeService.BisCodeSpecIndexProps): void;
    }
    // (undocumented)
    export interface InternalWriteMethods extends WriteMethods {
        // @internal (undocumented)
        reserveBisCodeSpecs(specs: CodeService.BisCodeSpecIndexProps[]): Promise<void>;
        // @internal (undocumented)
        reserveEmbeddedFaceDataId(facesKey: string): Promise<number>;
        // @internal (undocumented)
        reserveFontId(props: CodeService.FontIndexProps): Promise<FontId>;
    }
    export type IterationReturn = void | "stop";
    export function makeProposedCode(arg: CodeService.MakeProposedCodeArgs): CodeService.ProposedCode;
    export interface MakeProposedCodeArgs {
        // (undocumented)
        readonly code: Required<CodeProps>;
        // (undocumented)
        readonly iModel: IModelDb;
        // (undocumented)
        readonly props: CodeService.CodeGuidStateJson;
    }
    export function makeScopeAndSpec(iModel: IModelDb, code: CodeProps): CodeService.ScopeAndSpec;
    export interface NameAndJson {
        // (undocumented)
        readonly json?: SettingsContainer;
        // (undocumented)
        readonly name: string;
    }
    export type NameAndJsonIteration = (nameAndJson: NameAndJson) => IterationReturn;
    export type ProposedCode = ProposedCodeProps & ScopeSpecAndValue;
    export interface ProposedCodeProps extends CodeGuidStateJson {
        value?: CodeValue;
    }
    // (undocumented)
    export interface ReadMethods {
        findCode(code: CodeService.ScopeSpecAndValue): CodeService.CodeGuid | undefined;
        findHighestUsed(from: CodeService.SequenceScope): CodeService.CodeValue | undefined;
        findNextAvailable(from: CodeService.SequenceScope): CodeService.CodeValue;
        forAllCodes(iter: CodeService.CodeIteration, filter?: CodeService.CodeFilter): void;
        forAllCodeSpecs(iter: CodeService.NameAndJsonIteration, filter?: CodeService.ValueFilter): void;
        getCode(guid: CodeService.CodeGuid): CodeService.CodeEntry | undefined;
        getCodeSpec(props: CodeService.CodeSpecName): CodeService.NameAndJson;
        isCodePresent(guid: CodeService.CodeGuid): boolean;
        verifyCode(specName: string, arg: CodeService.ElementCodeProps): void;
    }
    export function registerSequence(seq: CodeSequence): void;
    export interface ReserveCodesArgs {
        readonly allOrNothing?: true;
        readonly codes: CodeService.ProposedCode[];
    }
    export interface ReserveNextArgs {
        readonly code: CodeService.ProposedCodeProps;
        readonly from: SequenceScope;
    }
    export interface ReserveNextArrayArgs {
        readonly asManyAsPossible?: true;
        readonly codes: CodeService.ProposedCodeProps[];
        readonly from: CodeService.SequenceScope;
    }
    export interface ReserveProblem {
        readonly code: ProposedCode;
        readonly errorId: ErrorId;
        readonly message: string;
    }
    export interface ScopeAndSpec {
        // (undocumented)
        readonly scopeGuid: ScopeGuid;
        // (undocumented)
        readonly specName: CodeSpecName;
    }
    export type ScopeGuid = GuidString;
    export interface ScopeSpecAndValue extends ScopeAndSpec {
        // (undocumented)
        readonly value: CodeValue;
    }
    export interface SequenceScope extends ScopeAndSpec {
        readonly seq: CodeSequence;
        readonly start?: CodeValue;
    }
    export interface UpdateCodesArgs {
        readonly allOrNothing?: true;
        readonly props: CodeService.UpdatedCode[];
    }
    export type UpdatedCode = MarkRequired<Partial<ProposedCode>, "guid">;
    export interface UpdateProblem {
        readonly errorId: ErrorId;
        readonly message: string;
        readonly prop: UpdatedCode;
    }
    export interface ValueFilter {
        readonly orderBy?: "ASC" | "DESC";
        readonly sqlExpression?: string;
        readonly value?: string;
        readonly valueCompare?: "GLOB" | "LIKE" | "NOT GLOB" | "NOT LIKE" | "=" | "<" | ">";
    }
    // (undocumented)
    export interface WriteMethods {
        addAllCodes(iModel: IModelDb): Promise<number>;
        addCodeSpec(val: CodeService.NameAndJson): Promise<void>;
        deleteCodes(guid: CodeService.CodeGuid[]): Promise<void>;
        reserveCode(code: CodeService.ProposedCode): Promise<void>;
        reserveCodes(arg: CodeService.ReserveCodesArgs): Promise<number>;
        reserveNextAvailableCode(arg: CodeService.ReserveNextArgs): Promise<void>;
        reserveNextAvailableCodes(arg: CodeService.ReserveNextArrayArgs): Promise<number>;
        updateCode(props: CodeService.UpdatedCode): Promise<void>;
        updateCodes(arg: CodeService.UpdateCodesArgs): Promise<number>;
    }
}

// @public @preview
export class CodeSpecs {
    constructor(imodel: IModelDb);
    getById(codeSpecId: Id64String): CodeSpec;
    getByName(name: string): CodeSpec;
    hasId(codeSpecId: Id64String): boolean;
    hasName(name: string): boolean;
    insert(codeSpec: CodeSpec): Id64String;
    insert(name: string, properties: CodeSpecProperties | CodeScopeSpec.Type): Id64String;
    load(id: Id64String): CodeSpec;
    queryId(name: string): Id64String;
    updateProperties(codeSpec: CodeSpec): void;
}

// @public
export interface ComputedProjectExtents {
    extents: Range3d;
    extentsWithOutliers?: Range3d;
    outliers?: Id64Array;
}

// @beta
export function computeElbowDirection(attachmentPoint: Point3d, frameCurve: Loop | Path, elbowLength: number): Vector3d | undefined;

// @beta
export function computeFrame(args: ComputeFrameArgs): Loop | Path;

// @beta
export interface ComputeFrameArgs {
    frame: Exclude<TextAnnotationFrameShape, "none">;
    range: Range2d;
    transform: Transform;
}

// @beta
export function computeGraphemeOffsets(args: ComputeGraphemeOffsetsArgs): Range2d[];

// @beta
export interface ComputeGraphemeOffsetsArgs extends LayoutTextArgs {
    graphemeCharIndexes: number[];
    runLayoutResult: RunLayoutResult;
    source: TextBlockComponent;
}

// @beta
export function computeIntervalPoints(input: ComputeIntervalPointsArgs): Point3d[] | undefined;

// @beta
export interface ComputeIntervalPointsArgs extends ComputeFrameArgs {
    arcIntervalFactor?: number;
    lineIntervalFactor?: number;
}

// @beta
export function computeLayoutTextBlockResult(args: LayoutTextBlockArgs): TextBlockLayoutResult;

// @beta
export function computeLeaderAttachmentPoint(leader: TextAnnotationLeader, frameCurve: Loop | Path, textLayout: TextBlockLayout, transform: Transform): Point3d | undefined;

// @public
export interface ComputeProjectExtentsOptions {
    reportExtentsWithOutliers?: boolean;
    reportOutliers?: boolean;
}

// @internal
export type ComputeRangesForTextLayout = (args: ComputeRangesForTextLayoutArgs) => TextLayoutRanges;

// @internal
export interface ComputeRangesForTextLayoutArgs {
    // (undocumented)
    baselineShift: BaselineShift;
    // (undocumented)
    bold: boolean;
    // (undocumented)
    chars: string;
    // (undocumented)
    fontId: FontId;
    // (undocumented)
    italic: boolean;
    // (undocumented)
    textHeight: number;
    // (undocumented)
    widthFactor: number;
}

// @alpha
export type ConcreteEntity = Element_2 | Model | ElementAspect | Relationship;

// @alpha
export type ConcreteEntityProps = ElementProps | ModelProps | ElementAspectProps | RelationshipProps;

// @beta
export function convertEC2SchemasToEC3Schemas(ec2XmlSchemas: string[], schemaContext?: ECSchemaXmlContext): string[];

// @internal
export interface CrashReportingConfig {
    crashDir: string;
    dumpProcessorScriptFileName?: string;
    enableCrashDumps?: boolean;
    enableNodeReport?: boolean;
    maxDumpsInDir?: number;
    params?: CrashReportingConfigNameValuePair[];
    uploadToBentley?: boolean;
    wantFullMemoryDumps?: boolean;
}

// @internal (undocumented)
export interface CrashReportingConfigNameValuePair {
    // (undocumented)
    name: string;
    // (undocumented)
    value: string;
}

// @beta
export interface CreateChangeSummaryArgs extends TokenArg {
    iModelId: GuidString;
    iTwinId: GuidString;
    range: ChangesetRange;
}

// @alpha
export interface CreateFontFileFromRscBlobArgs {
    blob: Uint8Array;
    encoding?: RscFontEncodingProps;
    familyName: string;
}

// @beta
export interface CreateFontFileFromShxBlobArgs {
    blob: Uint8Array;
    familyName: string;
}

// @public
export interface CreateNewIModelProps extends IModelNameArg {
    // (undocumented)
    readonly description?: string;
    // (undocumented)
    readonly noLocks?: true;
    // (undocumented)
    readonly version0?: LocalFileName;
}

// @beta
export interface CreateNewWorkspaceContainerArgs {
    dbName?: WorkspaceDbName;
    manifest: WorkspaceDbManifest;
    metadata: Omit<BlobContainer.Metadata, "containerType">;
    scope: BlobContainer.Scope;
}

// @beta
export interface CreateNewWorkspaceDbVersionArgs {
    fromProps?: WorkspaceDbProps;
    identifier?: string;
    versionType: CloudSqlite.SemverIncrement;
}

// @public
export interface CreateSheetViewDefinitionArgs {
    baseModelId: Id64String;
    categorySelectorId: Id64String;
    definitionModelId: Id64String;
    displayStyleId: Id64String;
    iModel: IModelDb;
    name: string;
    range: Range2d;
}

// @beta
export function createTerminatorGeometry(builder: ElementGeometry.Builder, point: Point3d, dir: Vector3d, params: GeometryParams, textStyleSettings: TextStyleSettings, textHeight: number): boolean;

// @beta
export interface CustomHandledProperty {
    readonly propertyName: string;
    readonly source: "Class" | "Computed";
}

// @beta
export interface DataTransformationResources extends PreImportCallbackResult {
    snapshot?: SnapshotDb;
}

// @beta
export enum DataTransformationStrategy {
    InMemory = "InMemory",
    None = "None",
    Snapshot = "Snapshot"
}

// @public @preview
export class DefinitionContainer extends DefinitionSet {
    // (undocumented)
    static get className(): string;
    static create(iModelDb: IModelDb, definitionModelId: Id64String, code: Code, isPrivate?: boolean): DefinitionContainer;
    static insert(iModelDb: IModelDb, definitionModelId: Id64String, code: Code, isPrivate?: boolean): Id64String;
}

// @public @preview
export abstract class DefinitionElement extends InformationContentElement {
    protected constructor(props: DefinitionElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // @beta
    static deserialize(props: DeserializeEntityArgs): DefinitionElementProps;
    isPrivate: boolean;
    // @beta
    static serialize(props: DefinitionElementProps, iModel: IModelDb): ECSqlRow;
    // (undocumented)
    toJSON(): DefinitionElementProps;
}

// @public @preview
export class DefinitionGroup extends DefinitionSet {
    // (undocumented)
    static get className(): string;
    static create(iModelDb: IModelDb, definitionModelId: Id64String, code: Code, isPrivate?: boolean): DefinitionGroup;
}

// @public
export class DefinitionGroupGroupsDefinitions extends ElementGroupsMembers {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export class DefinitionModel extends InformationModel {
    // (undocumented)
    static get className(): string;
    static insert(iModelDb: IModelDb, parentSubjectId: Id64String, name: string): Id64String;
}

// @public @preview
export class DefinitionPartition extends InformationPartitionElement {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class DefinitionSet extends DefinitionElement {
    // (undocumented)
    static get className(): string;
}

// @beta
export function deleteElementSubTrees(iModel: IModelDb, topElement: Id64String, filter: ElementSubTreeDeleteFilter): void;

// @beta
export function deleteElementTree(iModel: IModelDb, topElement: Id64String): void;

// @beta
export function deleteElementTree(args: DeleteElementTreeArgs): void;

// @beta
export interface DeleteElementTreeArgs {
    iModel: IModelDb;
    maxPasses?: number;
    topElement: Id64String;
}

// @beta
export interface DeserializeEntityArgs {
    iModel: IModelDb;
    options?: {
        element?: ElementLoadOptions;
    };
    row: ECSqlRow;
}

// @public
export class DetailCallout extends Callout {
    constructor(props: CalloutProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export abstract class DetailingSymbol extends GraphicalElement2d {
    constructor(props: GeometricElement2dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @internal
export class DevTools {
    static ping(): boolean;
    static setLogLevel(inLoggerCategory: string, newLevel: LogLevel): LogLevel | undefined;
    static stats(): DevToolsStats;
    static versions(): Promise<{
        application: string;
        iTwinJs: any;
        availableRpcs: RpcInterfaceEndpoints[];
    }>;
}

// @internal
export interface DevToolsOsStats {
    // (undocumented)
    cpus: os.CpuInfo[];
    // (undocumented)
    cpuUsage: number;
    // (undocumented)
    freemem: number;
    // (undocumented)
    hostname: string;
    // (undocumented)
    platform: NodeJS.Platform;
    // (undocumented)
    totalmem: number;
    // (undocumented)
    uptime: number;
}

// @internal
export interface DevToolsProcessStats {
    // (undocumented)
    memoryUsage: NodeJS.MemoryUsage;
    // (undocumented)
    pid: number;
    // (undocumented)
    ppid: number;
    // (undocumented)
    uptime: number;
}

// @internal
export interface DevToolsStats {
    // (undocumented)
    os: DevToolsOsStats;
    // (undocumented)
    process: DevToolsProcessStats;
}

// @internal
export class DevToolsStatsFormatter {
    static toFormattedJson(stats: any): any;
}

// @public @preview
export class DictionaryModel extends DefinitionModel {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class DisplayStyle extends DefinitionElement {
    protected constructor(props: DisplayStyleProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
    // @beta (undocumented)
    static deserialize(props: DeserializeEntityArgs): DisplayStyleProps;
    // (undocumented)
    loadScheduleScript(): RenderSchedule.ScriptReference | undefined;
    // @alpha (undocumented)
    protected static onCloned(context: IModelElementCloneContext, sourceElementProps: DisplayStyleProps, targetElementProps: DisplayStyleProps): Promise<void>;
    // @beta (undocumented)
    static serialize(props: DisplayStyleProps, iModel: IModelDb): ECSqlRow;
    // (undocumented)
    abstract get settings(): DisplayStyleSettings;
}

// @public @preview
export class DisplayStyle2d extends DisplayStyle {
    protected constructor(props: DisplayStyleProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static create(iModelDb: IModelDb, definitionModelId: Id64String, name: string): DisplayStyle2d;
    static insert(iModelDb: IModelDb, definitionModelId: Id64String, name: string): Id64String;
    // (undocumented)
    get settings(): DisplayStyleSettings;
}

// @public @preview
export class DisplayStyle3d extends DisplayStyle {
    protected constructor(props: DisplayStyle3dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    static create(iModelDb: IModelDb, definitionModelId: Id64String, name: string, options?: DisplayStyleCreationOptions): DisplayStyle3d;
    static insert(iModelDb: IModelDb, definitionModelId: Id64String, name: string, options?: DisplayStyleCreationOptions): Id64String;
    // @alpha (undocumented)
    protected static onCloned(context: IModelElementCloneContext, sourceElementProps: DisplayStyle3dProps, targetElementProps: DisplayStyle3dProps): Promise<void>;
    // (undocumented)
    get settings(): DisplayStyle3dSettings;
}

// @public @preview
export interface DisplayStyleCreationOptions extends Omit<DisplayStyle3dSettingsProps, "backgroundColor" | "scheduleScript"> {
    // (undocumented)
    backgroundColor?: ColorDef | number;
    viewFlags?: ViewFlags;
}

// @public @preview
abstract class Document_2 extends InformationContentElement {
    protected constructor(props: ElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}
export { Document_2 as Document }

// @public @preview
export class DocumentListModel extends InformationModel {
    // (undocumented)
    static get className(): string;
    static insert(iModelDb: IModelDb, parentSubjectId: Id64String, name: string): Id64String;
}

// @public @preview
export class DocumentPartition extends InformationPartitionElement {
    // (undocumented)
    static get className(): string;
}

// @public
export interface DownloadChangesetArg extends ChangesetArg, DownloadProgressArg {
    targetDir: LocalDirName;
}

// @public
export interface DownloadChangesetRangeArg extends ChangesetRangeArg, DownloadProgressArg {
    targetDir: LocalDirName;
}

// @internal (undocumented)
export interface DownloadJob {
    // (undocumented)
    promise?: Promise<any>;
    // (undocumented)
    request: DownloadRequest;
}

// @public
export interface DownloadProgressArg {
    progressCallback?: ProgressFunction;
}

// @internal
export interface DownloadRequest {
    readonly aliasFiles?: ReadonlyArray<string>;
    readonly checkpoint: CheckpointProps;
    localFile: LocalFileName;
    readonly onProgress?: ProgressFunction;
}

// @internal (undocumented)
export class Downloads {
    // (undocumented)
    static download<T>(request: DownloadRequest, downloadFn: (job: DownloadJob) => Promise<T>): Promise<any>;
    // (undocumented)
    static isInProgress(pathName: LocalFileName): DownloadJob | undefined;
}

// @public @preview
export class Drawing extends Document_2 {
    protected constructor(props: DrawingProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
    protected static get drawingModelFullClassName(): string;
    static insert(iModelDb: IModelDb, documentListModelId: Id64String, name: string, scaleFactor?: number): Id64String;
    // @preview
    get scaleFactor(): number;
    set scaleFactor(factor: number);
    // (undocumented)
    toJSON(): DrawingProps;
}

// @public @preview
export class DrawingCategory extends Category {
    protected constructor(opts: ElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static create(iModelDb: IModelDb, definitionModelId: Id64String, name: string): DrawingCategory;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
    static getCodeSpecName(): string;
    static insert(iModelDb: IModelDb, definitionModelId: Id64String, name: string, defaultAppearance: SubCategoryAppearance.Props | SubCategoryAppearance): Id64String;
    static queryCategoryIdByName(iModel: IModelDb, scopeModelId: Id64String, categoryName: string): Id64String | undefined;
}

// @public @preview
export class DrawingGraphic extends GraphicalElement2d {
    protected constructor(props: GeometricElement2dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export class DrawingGraphicRepresentsElement extends ElementRefersToElements {
    // (undocumented)
    static get className(): string;
}

// @public
export class DrawingGraphicRepresentsFunctionalElement extends DrawingGraphicRepresentsElement {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export class DrawingModel extends GraphicalModel2d {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export class DrawingViewDefinition extends ViewDefinition2d {
    protected constructor(props: ViewDefinition2dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static create(iModelDb: IModelDb, definitionModelId: Id64String, name: string, baseModelId: Id64String, categorySelectorId: Id64String, displayStyleId: Id64String, range: Range2d): DrawingViewDefinition;
    static fromJSON(props: Omit<ViewDefinition2dProps, "classFullName">, iModel: IModelDb): DrawingViewDefinition;
    static insert(iModelDb: IModelDb, definitionModelId: Id64String, name: string, baseModelId: Id64String, categorySelectorId: Id64String, displayStyleId: Id64String, range: Range2d): Id64String;
}

// @beta
export abstract class DriverBundleElement extends InformationContentElement {
    protected constructor(props: ElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @beta
export interface ECChangeUnifierCache extends Disposable {
    all(): IterableIterator<ChangedECInstance>;
    count(): number;
    get(key: string): ChangedECInstance | undefined;
    set(key: string, value: ChangedECInstance): void;
}

// @beta (undocumented)
export namespace ECChangeUnifierCache {
    export function createInMemoryCache(): ECChangeUnifierCache;
    export function createSqliteBackedCache(db: AnyDb, bufferedReadInstanceSizeInBytes?: number): ECChangeUnifierCache;
}

// @public
export class ECDb implements Disposable {
    // @internal (undocumented)
    get [_nativeDb](): IModelJsNative.ECDb;
    [Symbol.dispose](): void;
    constructor();
    abandonChanges(): void;
    attachDb(fileName: string, alias: string): void;
    // @internal
    clearStatementCache(): void;
    closeDb(): void;
    createDb(pathName: string): void;
    createQueryReader(ecsql: string, params?: QueryBinder, config?: QueryOptions): ECSqlReader;
    detachDb(alias: string): void;
    // @deprecated (undocumented)
    dispose(): void;
    // @alpha
    dropSchemas(schemaNames: string[]): void;
    // @internal
    getCachedStatementCount(): number;
    getSchemaProps(name: string): ECSchemaProps;
    importSchema(pathName: string): void;
    get isOpen(): boolean;
    openDb(pathName: string, openMode?: ECDbOpenMode): void;
    // @internal
    prepareSqliteStatement(sql: string, logErrors?: boolean): SqliteStatement;
    // @deprecated
    prepareStatement(ecsql: string, logErrors?: boolean): ECSqlStatement;
    // @beta
    prepareWriteStatement(ecsql: string, logErrors?: boolean): ECSqlWriteStatement;
    // @internal
    resetSqliteCache(size: number): void;
    saveChanges(changesetName?: string): void;
    // @beta
    withCachedWriteStatement<T>(ecsql: string, callback: (stmt: ECSqlWriteStatement) => T, logErrors?: boolean): T;
    withPreparedSqliteStatement<T>(sql: string, callback: (stmt: SqliteStatement) => T, logErrors?: boolean): T;
    // @deprecated
    withPreparedStatement<T>(ecsql: string, callback: (stmt: ECSqlStatement) => T, logErrors?: boolean): T;
    withSqliteStatement<T>(sql: string, callback: (stmt: SqliteStatement) => T, logErrors?: boolean): T;
    // @deprecated
    withStatement<T>(ecsql: string, callback: (stmt: ECSqlStatement) => T, logErrors?: boolean): T;
    // @beta
    withWriteStatement<T>(ecsql: string, callback: (stmt: ECSqlWriteStatement) => T, logErrors?: boolean): T;
}

// @public
export enum ECDbOpenMode {
    FileUpgrade = 2,
    // (undocumented)
    Readonly = 0,
    // (undocumented)
    ReadWrite = 1
}

// @public @deprecated
export interface ECEnumValue {
    // (undocumented)
    key: string;
    // (undocumented)
    name: string;
    // (undocumented)
    schema: string;
    // (undocumented)
    value: number | string;
}

// @public @preview
export class ECSchemaXmlContext {
    constructor();
    addSchemaPath(searchPath: string): void;
    // @internal (undocumented)
    get nativeContext(): IModelJsNative.ECSchemaXmlContext;
    readSchemaFromXmlFile(filePath: string): any;
    // @internal
    setFirstSchemaLocater(locater: IModelJsNative.ECSchemaXmlContext.SchemaLocaterCallback): void;
    // @internal
    setSchemaLocater(locater: IModelJsNative.ECSchemaXmlContext.SchemaLocaterCallback): void;
}

// @public
export class ECSqlBinder {
    // @internal
    constructor(binder: IModelJsNative.ECSqlBinder);
    addArrayElement(): ECSqlBinder;
    bind(val: any): void;
    bindArray(val: any[]): void;
    bindBlob(blob: string | Uint8Array | ArrayBuffer | SharedArrayBuffer): void;
    bindBoolean(val: boolean): void;
    bindDateTime(isoDateTimeString: string): void;
    bindDouble(val: number): void;
    bindGuid(val: GuidString): void;
    bindId(val: Id64String): void;
    bindIdSet(vector: Id64String[]): void;
    bindInteger(val: number | string): void;
    bindMember(memberName: string): ECSqlBinder;
    bindNavigation(val: NavigationBindingValue): void;
    bindNull(): void;
    bindPoint2d(val: XAndY): void;
    bindPoint3d(val: XYAndZ): void;
    bindRange3d(val: LowAndHighXYZ): void;
    bindString(val: string): void;
    bindStruct(val: object): void;
}

// @public @deprecated
export interface ECSqlColumnInfo {
    getAccessString(): string;
    getOriginPropertyName(): string | undefined;
    getPropertyName(): string;
    getRootClassAlias(): string;
    getRootClassName(): string;
    getRootClassTableSpace(): string;
    getType(): ECSqlValueType;
    isEnum(): boolean;
    isGeneratedProperty(): boolean;
    isSystemProperty(): boolean;
}

// @public
export class ECSqlInsertResult {
    constructor(status: DbResult, id?: Id64String | undefined);
    // (undocumented)
    id?: Id64String | undefined;
    // (undocumented)
    status: DbResult;
}

// @beta
export interface ECSqlRow {
    // (undocumented)
    [key: string]: any;
}

// @public
export interface ECSqlRowArg {
    classIdsToClassNames?: boolean;
    rowFormat?: QueryRowFormat;
}

// @public @deprecated
export class ECSqlStatement implements IterableIterator<any>, Disposable {
    [Symbol.dispose](): void;
    [Symbol.iterator](): IterableIterator<any>;
    bindArray(parameter: number | string, val: any[]): void;
    bindBlob(parameter: number | string, blob: string | Uint8Array | ArrayBuffer | SharedArrayBuffer): void;
    bindBoolean(parameter: number | string, val: boolean): void;
    bindDateTime(parameter: number | string, isoDateTimeString: string): void;
    bindDouble(parameter: number | string, val: number): void;
    bindGuid(parameter: number | string, val: GuidString): void;
    bindId(parameter: number | string, val: Id64String): void;
    // (undocumented)
    bindIdSet(parameter: number | string, val: Id64String[]): void;
    bindInteger(parameter: number | string, val: number | string): void;
    bindNavigation(parameter: number | string, val: NavigationBindingValue): void;
    bindNull(parameter: number | string): void;
    bindPoint2d(parameter: number | string, val: XAndY): void;
    bindPoint3d(parameter: number | string, val: XYAndZ): void;
    bindRange3d(parameter: number | string, val: LowAndHighXYZ): void;
    bindString(parameter: number | string, val: string): void;
    bindStruct(parameter: number | string, val: object): void;
    bindValue(parameter: number | string, val: any): void;
    bindValues(values: any[] | object): void;
    clearBindings(): void;
    // @deprecated (undocumented)
    dispose(): void;
    getBinder(parameter: string | number): ECSqlBinder;
    getColumnCount(): number;
    // @internal
    getNativeSql(): string;
    getRow(args?: ECSqlRowArg): any;
    getValue(columnIx: number): ECSqlValue;
    get isPrepared(): boolean;
    next(): IteratorResult<any>;
    // @internal
    prepare(db: IModelJsNative.DgnDb | IModelJsNative.ECDb, ecsql: string, logErrors?: boolean): void;
    reset(): void;
    // (undocumented)
    get sql(): string;
    step(): DbResult;
    // @internal
    stepAsync(): Promise<DbResult>;
    stepForInsert(): ECSqlInsertResult;
    // @internal
    tryPrepare(db: IModelJsNative.DgnDb | IModelJsNative.ECDb, ecsql: string, logErrors?: boolean): {
        status: DbResult;
        message: string;
    };
}

// @public @deprecated
export class ECSqlValue {
    // @internal
    constructor(val: IModelJsNative.ECSqlValue);
    get columnInfo(): ECSqlColumnInfo;
    getArray(): any[];
    getArrayIterator(): ECSqlValueIterator;
    getBlob(): Uint8Array;
    getBoolean(): boolean;
    getClassNameForClassId(): string;
    getDateTime(): string;
    getDouble(): number;
    getEnum(): ECEnumValue[] | undefined;
    getGeometry(): any;
    getGuid(): GuidString;
    getId(): Id64String;
    getInteger(): number;
    getNavigation(): NavigationValue;
    getString(): string;
    getStruct(): any;
    getStructIterator(): ECSqlValueIterator;
    getXAndY(): XAndY;
    getXYAndZ(): XYAndZ;
    get isNull(): boolean;
    get value(): any;
}

// @public @deprecated
export class ECSqlValueIterator implements IterableIterator<ECSqlValue> {
    // (undocumented)
    [Symbol.iterator](): IterableIterator<ECSqlValue>;
    // @internal
    constructor(it: IModelJsNative.ECSqlValueIterator);
    // (undocumented)
    next(): IteratorResult<ECSqlValue>;
}

// @public
export class ECSqlWriteStatement {
    [Symbol.dispose](): void;
    constructor(stmt?: ECSqlStatement);
    bindArray(parameter: number | string, val: any[]): void;
    bindBlob(parameter: number | string, blob: string | Uint8Array | ArrayBuffer | SharedArrayBuffer): void;
    bindBoolean(parameter: number | string, val: boolean): void;
    bindDateTime(parameter: number | string, isoDateTimeString: string): void;
    bindDouble(parameter: number | string, val: number): void;
    bindGuid(parameter: number | string, val: GuidString): void;
    bindId(parameter: number | string, val: Id64String): void;
    // (undocumented)
    bindIdSet(parameter: number | string, val: Id64String[]): void;
    bindInteger(parameter: number | string, val: number | string): void;
    bindNavigation(parameter: number | string, val: NavigationBindingValue): void;
    bindNull(parameter: number | string): void;
    bindPoint2d(parameter: number | string, val: XAndY): void;
    bindPoint3d(parameter: number | string, val: XYAndZ): void;
    bindRange3d(parameter: number | string, val: LowAndHighXYZ): void;
    bindString(parameter: number | string, val: string): void;
    bindStruct(parameter: number | string, val: object): void;
    bindValue(parameter: number | string, val: any): void;
    bindValues(values: any[] | object): void;
    clearBindings(): void;
    getBinder(parameter: string | number): ECSqlBinder;
    getColumnCount(): number;
    // @internal
    getNativeSql(): string;
    get isPrepared(): boolean;
    // @internal
    prepare(db: IModelJsNative.ECDb, ecsql: string, logErrors?: boolean): void;
    reset(): void;
    // (undocumented)
    get sql(): string;
    // (undocumented)
    step(): DbResult;
    stepForInsert(): ECSqlInsertResult;
    // @internal
    get stmt(): ECSqlStatement;
    // @internal
    tryPrepare(db: IModelJsNative.DgnDb | IModelJsNative.ECDb, ecsql: string, logErrors?: boolean): {
        status: DbResult;
        message: string;
    };
}

// @beta
export interface EditableCatalogDb extends CatalogDb {
    updateCatalogManifest(manifest: CatalogIModel.Manifest): void;
}

// @beta
export interface EditableWorkspaceContainer extends WorkspaceContainer {
    abandonChanges(): void;
    acquireWriteLock(user: string): void;
    readonly cloudProps: WorkspaceContainerProps | undefined;
    createDb(args: {
        dbName?: WorkspaceDbName;
        version?: WorkspaceDbVersion;
        manifest: WorkspaceDbManifest;
    }): Promise<EditableWorkspaceDb>;
    createNewWorkspaceDbVersion(props: CreateNewWorkspaceDbVersionArgs): Promise<{
        oldDb: WorkspaceDbNameAndVersion;
        newDb: WorkspaceDbNameAndVersion;
    }>;
    getEditableDb(props: WorkspaceDbProps): EditableWorkspaceDb;
    releaseWriteLock(): void;
}

// @beta
export interface EditableWorkspaceDb extends WorkspaceDb {
    addBlob(rscName: WorkspaceResourceName, val: Uint8Array): void;
    addFile(rscName: WorkspaceResourceName, localFileName: LocalFileName, fileExt?: string): void;
    addString(rscName: WorkspaceResourceName, val: string): void;
    get cloudProps(): WorkspaceDbCloudProps | undefined;
    // (undocumented)
    readonly container: EditableWorkspaceContainer;
    // @internal
    getBlobWriter(rscName: WorkspaceResourceName): SQLiteDb.BlobIO;
    removeBlob(rscName: WorkspaceResourceName): void;
    removeFile(rscName: WorkspaceResourceName): void;
    removeString(rscName: WorkspaceResourceName): void;
    updateBlob(rscName: WorkspaceResourceName, val: Uint8Array): void;
    updateFile(rscName: WorkspaceResourceName, localFileName: LocalFileName): void;
    updateManifest(manifest: WorkspaceDbManifest): void;
    updateSettingsResource(settings: SettingsContainer, rscName?: string): void;
    updateString(rscName: WorkspaceResourceName, val: string): void;
}

// @public @preview
class Element_2 extends Entity {
    protected constructor(props: ElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    code: Code;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    delete(): void;
    // @beta
    static deserialize(props: DeserializeEntityArgs): ElementProps;
    federationGuid?: GuidString;
    // @deprecated
    getClassMetaData(): EntityMetaData | undefined;
    getDisplayLabel(): string;
    getJsonProperty(nameSpace: string): any;
    getMetaData(): Promise<EntityClass>;
    getToolTipMessage(): string[];
    getUserProperties(namespace: string): any;
    insert(): string;
    readonly jsonProperties: {
        [key: string]: any;
    };
    readonly model: Id64String;
    // @beta
    protected static onAllInputsHandled(_id: Id64String, _iModel: IModelDb): void;
    // @beta
    protected static onBeforeOutputsHandled(_id: Id64String, _iModel: IModelDb): void;
    // @beta
    protected static onChildAdd(_arg: OnChildElementPropsArg): void;
    // @beta
    protected static onChildAdded(arg: OnChildElementIdArg): void;
    // @beta
    protected static onChildDelete(_arg: OnChildElementIdArg): void;
    // @beta
    protected static onChildDeleted(arg: OnChildElementIdArg): void;
    // @beta
    protected static onChildDrop(_arg: OnChildElementIdArg): void;
    // @beta
    protected static onChildDropped(arg: OnChildElementIdArg): void;
    // @beta
    protected static onChildInsert(_arg: OnChildElementPropsArg): void;
    // @beta
    protected static onChildInserted(arg: OnChildElementIdArg): void;
    // @beta
    protected static onChildUpdate(_arg: OnChildElementPropsArg): void;
    // @beta
    protected static onChildUpdated(arg: OnChildElementIdArg): void;
    // @beta
    protected static onCloned(_context: IModelElementCloneContext, _sourceProps: ElementProps, _targetProps: ElementProps): Promise<void> | void;
    // @beta
    protected static onDelete(arg: OnElementIdArg): void;
    // @beta
    protected static onDeleted(arg: OnElementIdArg): void;
    // @beta
    protected static onInsert(arg: OnElementPropsArg): void;
    // @beta
    protected static onInserted(arg: OnElementIdArg): void;
    // @beta
    protected static onSubModelDelete(_arg: OnSubModelIdArg): void;
    // @beta
    protected static onSubModelDeleted(arg: OnSubModelIdArg): void;
    // @beta
    protected static onSubModelInsert(_arg: OnSubModelPropsArg): void;
    // @beta
    protected static onSubModelInserted(arg: OnSubModelIdArg): void;
    // @beta
    protected static onUpdate(arg: OnElementPropsArg): void;
    // @beta
    protected static onUpdated(arg: OnElementIdArg): void;
    parent?: RelatedElement;
    // @internal (undocumented)
    static get protectedOperations(): string[];
    removeUserProperties(nameSpace: string): void;
    // @beta
    static readonly requiredReferenceKeys: ReadonlyArray<string>;
    // @alpha
    static readonly requiredReferenceKeyTypeMap: Record<string, ConcreteEntityTypes>;
    // @beta
    static serialize(props: ElementProps, iModel: IModelDb): ECSqlRow;
    // (undocumented)
    setJsonProperty(nameSpace: string, value: any): void;
    setUserProperties(nameSpace: string, value: any): void;
    // (undocumented)
    toJSON(): ElementProps;
    update(): void;
    userLabel?: string;
}
export { Element_2 as Element }

// @public @preview
export class ElementAspect extends Entity {
    constructor(props: ElementAspectProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    element: RelatedElement;
    // @beta
    protected static onDelete(arg: OnAspectIdArg): void;
    // @beta
    protected static onDeleted(_arg: OnAspectIdArg): void;
    // @beta
    protected static onInsert(arg: OnAspectPropsArg): void;
    // @beta
    protected static onInserted(_arg: OnAspectPropsArg): void;
    // @beta
    protected static onUpdate(arg: OnAspectPropsArg): void;
    // @beta
    protected static onUpdated(_arg: OnAspectPropsArg): void;
    // (undocumented)
    toJSON(): ElementAspectProps;
}

// @beta
export class ElementDrivesElement extends Relationship {
    protected constructor(props: ElementDrivesElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    // (undocumented)
    static create<T extends ElementDrivesElement>(iModel: IModelDb, sourceId: Id64String, targetId: Id64String, priority?: number): T;
    priority: number;
    status: number;
    // (undocumented)
    toJSON(): ElementDrivesElementProps;
}

// @beta
export interface ElementDrivesElementProps extends RelationshipProps {
    // (undocumented)
    priority: number;
    // (undocumented)
    status: number;
}

// @beta
export class ElementDrivesTextAnnotation extends ElementDrivesElement {
    // (undocumented)
    static get className(): string;
    static evaluateFields(args: EvaluateFieldsArgs): number;
    static isSupportedForIModel(iModel: IModelDb): boolean;
    // @internal (undocumented)
    static onDeletedDependency(props: RelationshipProps, iModel: IModelDb): void;
    // @internal (undocumented)
    static onRootChanged(props: RelationshipProps, iModel: IModelDb): void;
    static remapFields(clone: ITextAnnotation, context: IModelElementCloneContext): void;
    static updateFieldDependencies(annotationElementId: Id64String, iModel: IModelDb): void;
}

// @public
export class ElementEncapsulatesElements extends ElementOwnsChildElements {
    constructor(parentId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public
export class ElementGroupsMembers extends ElementRefersToElements {
    constructor(props: ElementGroupsMembersProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    static create<T extends ElementRefersToElements>(iModel: IModelDb, sourceId: Id64String, targetId: Id64String, memberPriority?: number): T;
    // (undocumented)
    memberPriority: number;
}

// @public
export interface ElementGroupsMembersProps extends RelationshipProps {
    // (undocumented)
    memberPriority: number;
}

// @public @preview
export class ElementMultiAspect extends ElementAspect {
    // (undocumented)
    static get className(): string;
}

// @public
export class ElementOwnsChannelRootAspect extends ElementOwnsUniqueAspect {
    constructor(elementId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public
export class ElementOwnsChildElements extends RelatedElement {
    constructor(parentId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public
export class ElementOwnsExternalSourceAspects extends ElementOwnsMultiAspects {
    constructor(elementId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public
export class ElementOwnsMultiAspects extends RelatedElement {
    constructor(elementId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public
export class ElementOwnsUniqueAspect extends RelatedElement {
    constructor(elementId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public
export class ElementRefersToElements extends Relationship {
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    static create<T extends ElementRefersToElements>(iModel: IModelDb, sourceId: Id64String, targetId: Id64String): T;
    static insert<T extends ElementRefersToElements>(iModel: IModelDb, sourceId: Id64String, targetId: Id64String): Id64String;
}

// @beta
export type ElementSubTreeDeleteFilter = (elementId: Id64String, scope: ElementTreeWalkerScope) => boolean;

// @beta
export class ElementSubTreeDeleter extends ElementTreeTopDown {
    constructor(iModel: IModelDb, shouldPruneCb: ElementSubTreeDeleteFilter);
    deleteNormalElementSubTrees(topElement: Id64String, scope?: ElementTreeWalkerScope): void;
    deleteSpecialElementSubTrees(): void;
    // (undocumented)
    protected prune(elementId: Id64String, scope: ElementTreeWalkerScope): void;
    // (undocumented)
    protected shouldPrune(elementId: Id64String, scope: ElementTreeWalkerScope): boolean;
}

// @beta
export abstract class ElementTreeBottomUp {
    constructor(_iModel: IModelDb);
    // (undocumented)
    protected _iModel: IModelDb;
    protected processElementTree(element: Id64String, scope: ElementTreeWalkerScope): void;
    protected shouldExploreChildren(_parentId: Id64String, _scope: ElementTreeWalkerScope): boolean;
    protected shouldExploreModel(_model: Model, _scope: ElementTreeWalkerScope): boolean;
    protected shouldVisitElement(_elementId: Id64String, _scope: ElementTreeWalkerScope): boolean;
    protected shouldVisitModel(_model: Model, _scope: ElementTreeWalkerScope): boolean;
    protected abstract visitElement(elementId: Id64String, scope: ElementTreeWalkerScope): void;
    protected abstract visitModel(model: Model, scope: ElementTreeWalkerScope): void;
}

// @beta
export class ElementTreeDeleter extends ElementTreeBottomUp {
    deleteNormalElements(topElement: Id64String, scope?: ElementTreeWalkerScope): void;
    deleteSpecialElements(): void;
    // (undocumented)
    protected shouldExploreModel(_model: Model): boolean;
    // (undocumented)
    protected shouldVisitElement(_elementId: Id64String): boolean;
    // (undocumented)
    protected _special: SpecialElements;
    // (undocumented)
    protected visitElement(elementId: Id64String, _scope: ElementTreeWalkerScope): void;
    // (undocumented)
    protected visitModel(model: Model, _scope: ElementTreeWalkerScope): void;
}

// @beta (undocumented)
export interface ElementTreeWalkerModelInfo {
    // (undocumented)
    isDefinitionModel: boolean;
    // (undocumented)
    model: Model;
}

// @beta
export class ElementTreeWalkerScope {
    constructor(topElement: Id64String, model: Model);
    constructor(enclosingScope: ElementTreeWalkerScope, newScope: Id64String | Model);
    // (undocumented)
    static createTopScope(iModel: IModelDb, topElementId: Id64String): ElementTreeWalkerScope;
    // (undocumented)
    get enclosingModel(): Model;
    readonly enclosingModelInfo: ElementTreeWalkerModelInfo;
    // (undocumented)
    get inDefinitionModel(): boolean;
    // (undocumented)
    get inRepositoryModel(): boolean;
    readonly path: Array<Id64String | ElementTreeWalkerModelInfo>;
    // (undocumented)
    readonly topElement: Id64String;
    // (undocumented)
    toString(): string;
}

// @public @preview
export class ElementUniqueAspect extends ElementAspect {
    // (undocumented)
    static get className(): string;
}

// @public
export class ElevationCallout extends Callout {
    constructor(props: CalloutProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public @preview
export class EmbeddedFileLink extends LinkElement {
    // (undocumented)
    static get className(): string;
}

// @beta
export interface EmbedFontFileArgs {
    file: FontFile;
    skipFontIdAllocation?: boolean;
}

// @public @preview
export class Entity {
    protected constructor(props: EntityProps, iModel: IModelDb);
    // @internal
    get asAny(): any;
    static get classFullName(): string;
    get classFullName(): string;
    static get className(): string;
    get className(): string;
    // @beta
    protected collectReferenceIds(_referenceIds: EntityReferenceSet): void;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // @beta
    static deserialize(props: DeserializeEntityArgs): EntityProps;
    forEach(func: PropertyHandler, includeCustom?: boolean): void;
    // @deprecated
    forEachProperty(func: PropertyCallback, includeCustom?: boolean): void;
    // @preview
    getMetaData(): Promise<EntityClass | RelationshipClass>;
    // @internal (undocumented)
    getMetaDataSync(): EntityClass | RelationshipClass;
    // @beta
    getReferenceIds(): EntityReferenceSet;
    id: Id64String;
    iModel: IModelDb;
    // @internal
    static instantiate(subclass: typeof Entity, props: EntityProps, iModel: IModelDb): Entity;
    static is(otherClass: typeof Entity): boolean;
    // @internal
    static get isGeneratedClass(): boolean;
    readonly isInstanceOfEntity: true;
    protected _metadata?: EntityClass | RelationshipClass;
    // @internal (undocumented)
    static get protectedOperations(): string[];
    static schema: typeof Schema;
    // @preview
    static get schemaItemKey(): SchemaItemKey;
    // @preview
    get schemaItemKey(): SchemaItemKey;
    get schemaName(): string;
    // @beta
    static serialize(props: EntityProps, _iModel: IModelDb): ECSqlRow;
    toJSON(): EntityProps;
}

// @public @preview
export type EntityClassType<T> = Function & {
    prototype: T;
};

// @public
export class EntityJsClassMap {
    // @internal (undocumented)
    [Symbol.iterator](): IterableIterator<[string, typeof Entity]>;
    // @internal (undocumented)
    clear(): void;
    // @internal (undocumented)
    delete(classFullName: string): boolean;
    // @internal (undocumented)
    get(classFullName: string): typeof Entity | undefined;
    // @internal (undocumented)
    has(classFullName: string): boolean;
    register(entityClass: typeof Entity, schema: typeof Schema): void;
    // @internal (undocumented)
    set(classFullName: string, entityClass: typeof Entity): void;
}

// @alpha
export namespace EntityReferences {
    export function from(entity: ConcreteEntity): EntityReference;
    export function fromClass(id: Id64String, entityClass: typeof Entity): EntityReference;
    export function fromEntityType(id: Id64String, type: ConcreteEntityTypes): EntityReference;
    // (undocumented)
    export function isElement(id: EntityReference): boolean;
    // (undocumented)
    export function isElementAspect(id: EntityReference): boolean;
    // (undocumented)
    export function isModel(id: EntityReference): boolean;
    // (undocumented)
    export function isRelationship(id: EntityReference): boolean;
    // @internal
    export function isValid(id: EntityReference): boolean;
    // @internal
    export function makeInvalid(type: ConcreteEntityTypes): EntityReference;
    export function split(id: EntityReference): [ConcreteEntityTypes, Id64String];
    // (undocumented)
    export function toId64(id: EntityReference): string;
    // @internal
    export function typeFromClass(entityClass: typeof Entity): ConcreteEntityTypes;
}

// @beta
export interface EvaluateFieldsArgs {
    block: TextBlock;
    iModel: IModelDb;
}

// @public
export namespace ExportGraphics {
    export function arePartDisplayInfosEqual(lhs: ExportPartDisplayInfo, rhs: ExportPartDisplayInfo): boolean;
    export function convertToIndexedPolyface(mesh: ExportGraphicsMesh): IndexedPolyface;
}

// @public
export type ExportGraphicsFunction = (info: ExportGraphicsInfo) => void;

// @public
export interface ExportGraphicsInfo {
    color: ColorDefProps;
    elementId: Id64String;
    geometryClass: GeometryClass;
    materialId?: Id64String;
    mesh: ExportGraphicsMesh;
    subCategory: Id64String;
    textureId?: Id64String;
}

// @public
export interface ExportGraphicsLines {
    indices: Int32Array;
    points: Float64Array;
}

// @public
export interface ExportGraphicsMesh {
    indices: Int32Array;
    isTwoSided: boolean;
    normals: Float32Array;
    params: Float32Array;
    points: Float64Array;
}

// @public
export class ExportGraphicsMeshSubsetVisitor extends ExportGraphicsMeshVisitor {
    static createSubsetVisitor(polyface: ExportGraphicsMesh, facetIndices: number[], numWrap?: number): ExportGraphicsMeshSubsetVisitor;
    getVisitableFacetCount(): number;
    moveToNextFacet(): boolean;
    moveToReadIndex(subsetIndex: number): boolean;
    parentFacetIndex(subsetIndex?: number): number | undefined;
    reset(): void;
}

// @public
export class ExportGraphicsMeshVisitor extends PolyfaceData implements PolyfaceVisitor {
    protected constructor(facets: ExportGraphicsMesh, numWrap: number);
    clearArrays(): void;
    clientAuxIndex(_i: number): number;
    clientColorIndex(_i: number): number;
    clientNormalIndex(i: number): number;
    clientParamIndex(i: number): number;
    clientPointIndex(i: number): number;
    clientPolyface(): Polyface | undefined;
    static create(polyface: ExportGraphicsMesh, numWrap?: number): ExportGraphicsMeshVisitor;
    createSubsetVisitor(facetIndices: number[], numWrap?: number): ExportGraphicsMeshSubsetVisitor;
    currentReadIndex(): number;
    getVisitableFacetCount(): number;
    moveToNextFacet(): boolean;
    moveToReadIndex(facetIndex: number): boolean;
    pushDataFrom(other: PolyfaceVisitor, index: number): void;
    pushInterpolatedDataFrom(other: PolyfaceVisitor, index0: number, fraction: number, index1: number): void;
    reset(): void;
    setNumWrap(numWrap: number): void;
}

// @public
export interface ExportGraphicsOptions {
    angleTol?: number;
    chordTol?: number;
    decimationTol?: number;
    elementIdArray: Id64Array;
    maxEdgeLength?: number;
    minBRepFeatureSize?: number;
    minLineStyleComponentSize?: number;
    onGraphics: ExportGraphicsFunction;
    onLineGraphics?: ExportLinesFunction;
    partInstanceArray?: ExportPartInstanceInfo[];
}

// @public
export type ExportLinesFunction = (info: ExportLinesInfo) => void;

// @public
export interface ExportLinesInfo {
    color: ColorDefProps;
    elementId: Id64String;
    geometryClass: GeometryClass;
    lines: ExportGraphicsLines;
    subCategory: Id64String;
}

// @public
export interface ExportPartDisplayInfo {
    // (undocumented)
    categoryId: Id64String;
    // (undocumented)
    elmTransparency: number;
    // (undocumented)
    geometryClass: GeometryClass;
    // (undocumented)
    lineColor: number;
    // (undocumented)
    materialId: Id64String;
    // (undocumented)
    subCategoryId: Id64String;
}

// @public
export type ExportPartFunction = (info: ExportPartInfo) => void;

// @public
export interface ExportPartGraphicsOptions {
    angleTol?: number;
    chordTol?: number;
    decimationTol?: number;
    displayProps: ExportPartDisplayInfo;
    elementId: Id64String;
    maxEdgeLength?: number;
    minBRepFeatureSize?: number;
    minLineStyleComponentSize?: number;
    onPartGraphics: ExportPartFunction;
    onPartLineGraphics?: ExportPartLinesFunction;
}

// @public
export interface ExportPartInfo {
    color: ColorDefProps;
    geometryClass: GeometryClass;
    materialId?: Id64String;
    mesh: ExportGraphicsMesh;
    textureId?: Id64String;
}

// @public
export interface ExportPartInstanceInfo {
    displayProps: ExportPartDisplayInfo;
    partId: Id64String;
    partInstanceId: Id64String;
    transform?: Float64Array;
}

// @public
export type ExportPartLinesFunction = (info: ExportPartLinesInfo) => void;

// @public
export interface ExportPartLinesInfo {
    color: ColorDefProps;
    geometryClass: GeometryClass;
    lines: ExportGraphicsLines;
}

// @beta
export interface ExportSchemaArgs {
    outputDirectory: LocalFileName;
    outputFileName?: string;
    schemaName: string;
}

// @beta
export class ExternalSource extends InformationReferenceElement {
    protected constructor(props: ExternalSourceProps, iModel: IModelDb);
    // @internal (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    connectorName?: string;
    connectorVersion?: string;
    static createCode(iModelDb: IModelDb, codeValue: string): Code;
    static ensureCodeSpec(iModelDb: IModelDb): Id64String;
    repository?: ExternalSourceIsInRepository;
    // (undocumented)
    toJSON(): ExternalSourceProps;
}

// @public @preview
export class ExternalSourceAspect extends ElementMultiAspect {
    constructor(props: ExternalSourceAspectProps, iModel: IModelDb);
    checksum?: string;
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    static findAllBySource(iModelDb: IModelDb, scope: Id64String, kind: string, identifier: string): Array<{
        elementId: Id64String;
        aspectId: Id64String;
    }>;
    identifier: string;
    jsonProperties?: string;
    kind: string;
    scope: RelatedElement;
    source?: RelatedElement;
    // (undocumented)
    toJSON(): ExternalSourceAspectProps;
    version?: string;
}

// @public @preview (undocumented)
export namespace ExternalSourceAspect {
    // @preview
    export enum Kind {
        Element = "Element",
        Relationship = "Relationship",
        Scope = "Scope"
    }
}

// @beta
export class ExternalSourceAttachment extends InformationReferenceElement {
    protected constructor(props: ExternalSourceAttachmentProps, iModel: IModelDb);
    attaches?: ExternalSourceAttachmentAttachesSource;
    // @internal (undocumented)
    static get className(): string;
    static createCode(iModelDb: IModelDb, scopeElementId: Id64String, codeValue: string): Code;
    static ensureCodeSpec(iModelDb: IModelDb): Id64String;
    pitch?: number;
    role?: ExternalSourceAttachmentRole;
    roll?: number;
    scale?: Point3d;
    // (undocumented)
    toJSON(): ExternalSourceAttachmentProps;
    translation?: Point3d;
    yaw?: number;
}

// @beta
export class ExternalSourceAttachmentAttachesSource extends RelatedElement {
    constructor(externalSourceId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @beta
export class ExternalSourceGroup extends ExternalSource {
    protected constructor(props: ExternalSourceProps, iModel: IModelDb);
    // @internal (undocumented)
    static get className(): string;
}

// @beta
export class ExternalSourceGroupGroupsSources extends ElementGroupsMembers {
    // (undocumented)
    static get className(): string;
}

// @beta
export class ExternalSourceIsInRepository extends RelatedElement {
    constructor(repositoryId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @beta
export class ExternalSourceOwnsAttachments extends ElementOwnsChildElements {
    constructor(parentId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public @deprecated
export abstract class FileNameResolver {
    resolveFileName(inFileName: string): string;
    resolveKey(fileKey: string): string;
    tryResolveFileName(inFileName: string): string | undefined;
    tryResolveKey(_fileKey: string): string | undefined;
}

// @internal
export type FindFontId = (name: string, type?: FontType) => FontId;

// @internal
export type FindTextStyle = (id: Id64String) => TextStyleSettings;

// @beta
export class FolderContainsRepositories extends ElementOwnsChildElements {
    constructor(parentId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @alpha
export class FolderLink extends UrlLink {
    // (undocumented)
    static get className(): string;
}

// @beta
export interface FontFile {
    // @internal
    readonly [_faceProps]: IModelJsNative.FontFaceProps[];
    // @internal
    readonly [_getData]: () => Uint8Array;
    // @internal (undocumented)
    readonly [_implementationProhibited]: unknown;
    // @internal
    readonly [_key]: string;
    readonly faces: ReadonlyArray<Readonly<FontFace_2>>;
    readonly isEmbeddable: boolean;
    readonly type: FontType;
}

// @beta (undocumented)
export namespace FontFile {
    // @alpha
    export function createFromRscFontBlob(args: CreateFontFileFromRscBlobArgs): FontFile;
    export function createFromShxFontBlob(args: CreateFontFileFromShxBlobArgs): FontFile;
    export function createFromTrueTypeFileName(fileName: LocalFileName): FontFile;
}

// @public
export abstract class FunctionalBreakdownElement extends FunctionalElement {
    protected constructor(props: FunctionalElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export abstract class FunctionalComponentElement extends FunctionalElement {
    protected constructor(props: FunctionalElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public (undocumented)
export class FunctionalComposite extends FunctionalBreakdownElement {
    protected constructor(props: FunctionalElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export abstract class FunctionalElement extends RoleElement {
    protected constructor(props: FunctionalElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export class FunctionalElementIsOfType extends RelatedElement {
    constructor(id: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
    // (undocumented)
    static get className(): string;
}

// @public
export class FunctionalModel extends RoleModel {
    constructor(props: ModelProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static insert(iModelDb: IModelDb, parentSubjectId: Id64String, name: string): Id64String;
}

// @public
export class FunctionalPartition extends InformationPartitionElement {
    protected constructor(props: InformationPartitionElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public (undocumented)
export class FunctionalSchema extends Schema {
    // (undocumented)
    static importSchema(iModelDb: IModelDb): Promise<void>;
    // (undocumented)
    static registerSchema(): void;
    // (undocumented)
    static get schemaFilePath(): string;
    // (undocumented)
    static get schemaName(): string;
}

// @public
export abstract class FunctionalType extends TypeDefinitionElement {
    protected constructor(props: TypeDefinitionElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @internal (undocumented)
export interface GcsDbProps extends WorkspaceDbCloudProps {
    // (undocumented)
    priority?: number;
}

// @internal
export function generateElementGraphics(request: ElementGraphicsRequestProps, iModel: IModelDb): Promise<Uint8Array | undefined>;

// @public
export class GenericDocument extends Document_2 {
    constructor(props: ElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export class GenericGraphicalModel3d extends GraphicalModel3d {
    constructor(props: GeometricModel3dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static insert(iModelDb: IModelDb, parentSubjectId: Id64String, name: string, isPlanProjection?: boolean): Id64String;
}

// @public
export class GenericGraphicalType2d extends GraphicalType2d {
    constructor(props: TypeDefinitionElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export class GenericPhysicalMaterial extends PhysicalMaterial {
    constructor(props: DefinitionElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export class GenericPhysicalType extends PhysicalType {
    constructor(props: PhysicalTypeProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public (undocumented)
export class GenericSchema extends Schema {
    // (undocumented)
    static registerSchema(): void;
    // (undocumented)
    static get schemaFilePath(): string;
    // (undocumented)
    static get schemaName(): string;
}

// @internal
export class GeoCoordConfig {
    // (undocumented)
    static loadDefaultDatabases(): void;
    // (undocumented)
    static loadForImodel(settings: Settings): void;
    // (undocumented)
    static onStartup(): void;
    static readonly prefetches: CloudSqlite.CloudPrefetch[];
    // (undocumented)
    static readonly settingName: {
        databases: string;
        defaultDatabases: string;
        disableWorkspaces: string;
    };
}

// @public @preview
export abstract class GeometricElement extends Element_2 {
    protected constructor(props: GeometricElementProps, iModel: IModelDb);
    // (undocumented)
    calculateRange3d(): AxisAlignedBox3d;
    category: Id64String;
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // @beta
    static deserialize(props: DeserializeEntityArgs): GeometricElementProps;
    geom?: GeometryStreamProps;
    getPlacementTransform(): Transform;
    is2d(): this is GeometricElement2d;
    is3d(): this is GeometricElement3d;
    abstract get placement(): Placement2d | Placement3d;
    // @beta (undocumented)
    static readonly requiredReferenceKeys: ReadonlyArray<string>;
    // @alpha (undocumented)
    static readonly requiredReferenceKeyTypeMap: Record<string, ConcreteEntityTypes>;
    // @beta
    static serialize(props: GeometricElementProps, iModel: IModelDb): ECSqlRow;
    // (undocumented)
    toJSON(): GeometricElementProps;
}

// @public @preview
export abstract class GeometricElement2d extends GeometricElement {
    protected constructor(props: GeometricElement2dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // @beta
    static deserialize(props: DeserializeEntityArgs): GeometricElement2dProps;
    // (undocumented)
    placement: Placement2d;
    // @beta
    static serialize(props: GeometricElement2dProps, iModel: IModelDb): ECSqlRow;
    // (undocumented)
    toJSON(): GeometricElement2dProps;
    // (undocumented)
    typeDefinition?: TypeDefinition;
}

// @public
export class GeometricElement2dHasTypeDefinition extends TypeDefinition {
    constructor(id: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public @preview
export abstract class GeometricElement3d extends GeometricElement {
    protected constructor(props: GeometricElement3dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // @beta
    static deserialize(props: DeserializeEntityArgs): GeometricElement3dProps;
    // (undocumented)
    placement: Placement3d;
    // @beta
    static serialize(props: GeometricElement3dProps, iModel: IModelDb): ECSqlRow;
    // (undocumented)
    toJSON(): GeometricElement3dProps;
    // (undocumented)
    typeDefinition?: TypeDefinition;
}

// @public
export class GeometricElement3dHasTypeDefinition extends TypeDefinition {
    constructor(id: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public @preview
export class GeometricModel extends Model {
    protected constructor(props: GeometricModelProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    geometryGuid?: GuidString;
    queryExtents(): AxisAlignedBox3d;
    queryRange(): Promise<AxisAlignedBox3d>;
}

// @public @preview
export abstract class GeometricModel2d extends GeometricModel {
    protected constructor(props: GeometricModel2dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    globalOrigin?: Point2d;
    // (undocumented)
    toJSON(): GeometricModel2dProps;
}

// @public @preview
export abstract class GeometricModel3d extends GeometricModel {
    protected constructor(props: GeometricModel3dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // @beta
    static deserialize(props: DeserializeEntityArgs): GeometricModel3dProps;
    readonly isNotSpatiallyLocated: boolean;
    readonly isPlanProjection: boolean;
    get isSpatiallyLocated(): boolean;
    // @beta
    static serialize(props: GeometricModel3dProps, _iModel: IModelDb): ECSqlRow;
    // (undocumented)
    toJSON(): GeometricModel3dProps;
}

// @public @preview
export class GeometryPart extends DefinitionElement {
    protected constructor(props: GeometryPartProps, iModel: IModelDb);
    // (undocumented)
    bbox: ElementAlignedBox3d;
    // (undocumented)
    static get className(): string;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // @beta
    static deserialize(props: DeserializeEntityArgs): GeometryPartProps;
    // (undocumented)
    geom?: GeometryStreamProps;
    // @beta
    static serialize(props: GeometryPartProps, iModel: IModelDb): ECSqlRow;
    // (undocumented)
    toJSON(): GeometryPartProps;
}

// @beta
export function getAvailableCoordinateReferenceSystems(args: GetAvailableCoordinateReferenceSystemsArgs): Promise<AvailableCoordinateReferenceSystemProps[]>;

// @beta
export interface GetAvailableCoordinateReferenceSystemsArgs {
    extent?: Range2dProps;
    includeWorld?: boolean;
}

// @beta
export interface GetWorkspaceContainerArgs extends WorkspaceContainerProps {
    accessToken: AccessToken;
}

// @beta
export interface GetWorkspaceResourceArgs {
    dbs: WorkspaceDb[];
    name: WorkspaceResourceName;
}

// @public
export class Graphic3d extends GraphicalElement3d {
    constructor(props: GeometricElement3dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class GraphicalElement2d extends GeometricElement2d {
    protected constructor(props: GeometricElement2dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export class GraphicalElement2dIsOfType extends GeometricElement2dHasTypeDefinition {
    constructor(id: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public @preview
export abstract class GraphicalElement3d extends GeometricElement3d {
    protected constructor(props: GeometricElement3dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export class GraphicalElement3dRepresentsElement extends ElementRefersToElements {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class GraphicalModel2d extends GeometricModel2d {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class GraphicalModel3d extends GeometricModel3d {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export class GraphicalPartition3d extends InformationPartitionElement {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class GraphicalType2d extends TypeDefinitionElement {
    protected constructor(props: TypeDefinitionElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
}

// @public
export class Group extends GroupInformationElement {
    constructor(props: ElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export class GroupImpartsToMembers extends ElementGroupsMembers {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class GroupInformationElement extends InformationReferenceElement {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class GroupInformationModel extends InformationModel {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export class GroupInformationPartition extends InformationPartitionElement {
    // (undocumented)
    static get className(): string;
}

// @public
export class GroupModel extends GroupInformationModel {
    constructor(props: ModelProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static insert(iModelDb: IModelDb, parentSubjectId: Id64String, name: string): Id64String;
}

// @public
export function imageBufferFromImageSource(args: ImageBufferFromImageSourceArgs): ImageBuffer | undefined;

// @public
export interface ImageBufferFromImageSourceArgs {
    source: BinaryImageSource;
    targetFormat?: ImageBufferFormat.Rgb | ImageBufferFormat.Rgba;
}

// @public
export function imageSourceFromImageBuffer(args: ImageSourceFromImageBufferArgs): BinaryImageSource | undefined;

// @public
export interface ImageSourceFromImageBufferArgs {
    flipVertically?: boolean;
    image: ImageBuffer;
    jpegQuality?: number;
    targetFormat?: ImageSourceFormat.Png | ImageSourceFormat.Jpeg;
}

// @public
export abstract class IModelDb extends IModel {
    // @internal (undocumented)
    readonly [_nativeDb]: IModelJsNative.DgnDb;
    // @internal (undocumented)
    [_resetIModelDb](): void;
    // @internal
    protected constructor(args: {
        nativeDb: IModelJsNative.DgnDb;
        key: string;
        changeset?: ChangesetIdWithIndex;
    });
    abandonChanges(): void;
    acquireSchemaLock(): Promise<void>;
    // @beta
    analyze(): void;
    attachDb(fileName: string, alias: string): void;
    // @internal
    protected beforeClose(): void;
    // @internal
    cancelSnap(sessionId: string): void;
    // @beta (undocumented)
    readonly channels: ChannelControl;
    // @internal @deprecated
    get classMetaDataRegistry(): MetaDataRegistry;
    clearCaches(): void;
    // @beta
    clearCaches(params?: ClearCachesOptions): void;
    // @internal (undocumented)
    clearFontMap(): void;
    close(options?: CloseIModelArgs): void;
    // @beta
    get cloudContainer(): CloudSqlite.CloudContainer | undefined;
    // @alpha (undocumented)
    get codeService(): CodeService | undefined;
    // @internal (undocumented)
    protected _codeService?: CodeService;
    get codeSpecs(): CodeSpecs;
    get codeValueBehavior(): "exact" | "trim-unicode-whitespace";
    set codeValueBehavior(newBehavior: "exact" | "trim-unicode-whitespace");
    computeProjectExtents(options?: ComputeProjectExtentsOptions): ComputedProjectExtents;
    // @internal (undocumented)
    computeRangesForText(args: ComputeRangesForTextLayoutArgs): TextLayoutRanges;
    constructEntity<T extends Entity, P extends EntityProps = EntityProps>(props: P): T;
    containsClass(classFullName: string): boolean;
    // @alpha
    createBRepGeometry(createProps: BRepGeometryCreate): IModelStatus;
    createQueryReader(ecsql: string, params?: QueryBinder, config?: QueryOptions): ECSqlReader;
    // (undocumented)
    static readonly defaultLimit = 1000;
    deleteFileProperty(prop: FilePropertyProps): void;
    // @beta
    deleteSettingDictionary(name: string): void;
    detachDb(alias: string): void;
    // @alpha
    dropSchemas(schemaNames: string[]): Promise<void>;
    // @beta
    elementGeometryCacheOperation(requestProps: ElementGeometryCacheOperationRequestProps): BentleyStatus;
    // @beta
    elementGeometryRequest(requestProps: ElementGeometryRequest): IModelStatus;
    // (undocumented)
    readonly elements: IModelDb.Elements;
    exportGraphics(exportProps: ExportGraphicsOptions): DbResult;
    exportGraphicsAsync(exportProps: ExportGraphicsOptions): Promise<void>;
    exportPartGraphics(exportProps: ExportPartGraphicsOptions): DbResult;
    exportPartGraphicsAsync(exportProps: ExportPartGraphicsOptions): Promise<void>;
    // @beta
    exportSchema(args: ExportSchemaArgs): void;
    // @beta
    exportSchemas(outputDirectory: LocalFileName): void;
    static findByFilename(fileName: LocalFileName): IModelDb | undefined;
    static findByKey(key: string): IModelDb;
    // @deprecated (undocumented)
    get fontMap(): FontMap;
    // @deprecated (undocumented)
    protected _fontMap?: FontMap;
    // @beta
    get fonts(): IModelDbFonts;
    // @deprecated
    static forEachMetaData(iModel: IModelDb, classFullName: string, wantSuper: boolean, func: PropertyCallback, includeCustom?: boolean): void;
    // @deprecated
    forEachMetaData(classFullName: string, wantSuper: boolean, func: PropertyCallback, includeCustom?: boolean): void;
    generateElementGraphics(request: ElementGraphicsRequestProps): Promise<Uint8Array | undefined>;
    getBriefcaseId(): BriefcaseId;
    // @internal
    getClassNameFromId(classId: string): Id64String;
    getGeoCoordinatesFromIModelCoordinates(props: GeoCoordinatesRequestProps): Promise<GeoCoordinatesResponseProps>;
    getGeometryContainment(props: GeometryContainmentRequestProps): Promise<GeometryContainmentResponseProps>;
    getIModelCoordinatesFromGeoCoordinates(props: IModelCoordinatesRequestProps): Promise<IModelCoordinatesResponseProps>;
    // @internal
    getInstanceArgs(instanceId?: Id64String, baseClassName?: string, federationGuid?: GuidString, code?: CodeProps): IModelJsNative.ResolveInstanceKeyArgs;
    getJsClass<T extends typeof Entity>(classFullName: string): T;
    getLastError(): string;
    getMassProperties(props: MassPropertiesRequestProps): Promise<MassPropertiesResponseProps>;
    // @deprecated
    getMetaData(classFullName: string): EntityMetaData;
    getSchemaProps(name: string): ECSchemaProps;
    get holdsSchemaLock(): boolean;
    get iModelId(): GuidString;
    importSchemas(schemaFileNames: LocalFileName[], options?: SchemaImportOptions): Promise<void>;
    // @alpha
    importSchemaStrings(serializedXmlSchemas: string[], options?: SchemaImportOptions): Promise<void>;
    // @internal (undocumented)
    protected initializeIModelDb(when?: "pullMerge"): void;
    // @beta
    inlineGeometryParts(): InlineGeometryPartsResult;
    // @beta
    integrityCheck(options?: IntegrityCheckOptions): Promise<IntegrityCheckResult[]>;
    get isBriefcase(): boolean;
    isBriefcaseDb(): this is BriefcaseDb;
    // @internal
    get isOpen(): boolean;
    get isReadonly(): boolean;
    get isSnapshot(): boolean;
    isSnapshotDb(): this is SnapshotDb;
    // @internal
    get isStandalone(): boolean;
    isStandaloneDb(): this is StandaloneDb;
    get jsClassMap(): EntityJsClassMap;
    // @internal (undocumented)
    protected loadWorkspaceSettings(): Promise<void>;
    get locks(): LockControl;
    // @internal (undocumented)
    protected _locks?: LockControl;
    // (undocumented)
    static readonly maxLimit = 10000;
    // @beta
    meetsMinimumSchemaVersion(schemaName: string, minimumVersion: ECVersion): boolean;
    // (undocumented)
    readonly models: IModelDb.Models;
    // @internal (undocumented)
    notifyChangesetApplied(): void;
    readonly onBeforeClose: BeEvent<() => void>;
    readonly onChangesetApplied: BeEvent<() => void>;
    // @internal (undocumented)
    static openDgnDb(file: {
        path: LocalFileName;
        key?: string;
    }, openMode: OpenMode, upgradeOptions?: UpgradeOptions, props?: SnapshotOpenOptions & CloudContainerArgs & OpenSqliteArgs): IModelJsNative.DgnDb;
    // @beta
    optimize(): void;
    get pathName(): LocalFileName;
    performCheckpoint(): void;
    // @internal
    prepareSqliteStatement(sql: string, logErrors?: boolean): SqliteStatement;
    // @deprecated
    prepareStatement(sql: string, logErrors?: boolean): ECSqlStatement;
    // @internal
    queryAllUsedSpatialSubCategories(): Promise<SubCategoryResultRow[]>;
    queryEntityIds(params: EntityQueryParams): Id64Set;
    queryFilePropertyBlob(prop: FilePropertyProps): Uint8Array | undefined;
    queryFilePropertyString(prop: FilePropertyProps): string | undefined;
    queryNextAvailableFileProperty(prop: FilePropertyProps): number;
    querySchemaVersion(schemaName: string): string | undefined;
    querySchemaVersionNumbers(schemaName: string): ECVersion | undefined;
    // @internal
    querySubCategories(categoryIds: Iterable<Id64String>): Promise<SubCategoryResultRow[]>;
    // @alpha
    queryTextureData(props: TextureLoadProps): Promise<TextureData | undefined>;
    // @internal (undocumented)
    refreshContainerForRpc(_userAccessToken: AccessToken): Promise<void>;
    // @internal (undocumented)
    reinstateTxn(): IModelStatus;
    get relationships(): Relationships;
    // @internal (undocumented)
    requestSnap(sessionId: string, props: SnapRequestProps): Promise<SnapResponseProps>;
    // @beta
    requireMinimumSchemaVersion(schemaName: string, minimumVersion: ECVersion, featureName: string): void;
    // @internal (undocumented)
    restartDefaultTxn(): void;
    // @internal (undocumented)
    restartTxnSession(): void;
    // @internal @deprecated (undocumented)
    reverseTxns(numOperations: number): IModelStatus;
    saveChanges(description?: string): void;
    // @alpha
    saveChanges(args: SaveChangesArgs): void;
    saveFileProperty(prop: FilePropertyProps, strValue: string | undefined, blobVal?: Uint8Array): void;
    // @beta
    saveSettingDictionary(name: string, dict: SettingsContainer): void;
    // @preview
    get schemaContext(): SchemaContext;
    get schemaMap(): SchemaMap;
    // @beta
    simplifyElementGeometry(args: SimplifyElementGeometryArgs): IModelStatus;
    // (undocumented)
    readonly tiles: IModelDb.Tiles;
    static tryFindByKey(key: string): IModelDb | undefined;
    // @deprecated
    tryGetMetaData(classFullName: string): EntityMetaData | undefined;
    // @deprecated
    tryPrepareStatement(sql: string): ECSqlStatement | undefined;
    updateEcefLocation(ecef: EcefLocation): void;
    // @beta
    updateElementGeometryCache(requestProps: ElementGeometryCacheRequestProps): Promise<ElementGeometryCacheResponseProps>;
    updateIModelProps(): void;
    updateProjectExtents(newExtents: AxisAlignedBox3d): void;
    // @beta
    vacuum(): void;
    static validateSchemas(filePath: LocalFileName, forReadWrite: boolean): SchemaState;
    // (undocumented)
    readonly views: IModelDb.Views;
    // @internal
    get watchFilePathName(): LocalFileName;
    withPreparedSqliteStatement<T>(sql: string, callback: (stmt: SqliteStatement) => T, logErrors?: boolean): T;
    // @deprecated
    withPreparedStatement<T>(ecsql: string, callback: (stmt: ECSqlStatement) => T, logErrors?: boolean): T;
    withSqliteStatement<T>(sql: string, callback: (stmt: SqliteStatement) => T, logErrors?: boolean): T;
    // @deprecated
    withStatement<T>(ecsql: string, callback: (stmt: ECSqlStatement) => T, logErrors?: boolean): T;
    // @beta
    get workspace(): Workspace;
}

// @public (undocumented)
export namespace IModelDb {
    // @preview
    export class Elements implements GuidMapper {
        // @internal (undocumented)
        readonly [_cache]: ElementLRUCache;
        // @internal (undocumented)
        readonly [_instanceKeyCache]: InstanceKeyLRUCache;
        // @internal
        constructor(_iModel: IModelDb);
        createElement<T extends Element_2>(elProps: ElementProps): T;
        deleteAspect(aspectInstanceIds: Id64Arg): void;
        // @beta
        deleteDefinitionElements(definitionElementIds: Id64Array): Id64Set;
        deleteElement(ids: Id64Arg): void;
        getAspect(aspectInstanceId: Id64String): ElementAspect;
        getAspects(elementId: Id64String, aspectClassFullName?: string, excludedClassFullNames?: Set<string>): ElementAspect[];
        getElement<T extends Element_2>(elementId: Id64String | GuidString | Code | ElementLoadProps, elementClass?: EntityClassType<Element_2>): T;
        getElementProps<T extends ElementProps>(props: Id64String | GuidString | Code | ElementLoadProps): T;
        // (undocumented)
        getFederationGuidFromId(id: Id64String): GuidString | undefined;
        // (undocumented)
        getIdFromFederationGuid(guid?: GuidString): Id64String | undefined;
        getRootSubject(): Subject;
        hasSubModel(elementId: Id64String): boolean;
        insertAspect(aspectProps: ElementAspectProps): Id64String;
        insertElement(elProps: ElementProps, options?: InsertElementOptions): Id64String;
        // @internal
        _queryAspects(elementId: Id64String, fromClassFullName: string, excludedClassFullNames?: Set<string>): ElementAspect[];
        queryChildren(elementId: Id64String): Id64String[];
        queryElementIdByCode(code: Required<CodeProps>): Id64String | undefined;
        queryLastModifiedTime(elementId: Id64String): string;
        queryParent(elementId: Id64String): Id64String | undefined;
        tryGetElement<T extends Element_2>(elementId: Id64String | GuidString | Code | ElementLoadProps, elementClass?: EntityClassType<Element_2>): T | undefined;
        tryGetElementProps<T extends ElementProps>(props: Id64String | GuidString | Code | ElementLoadProps): T | undefined;
        updateAspect(aspectProps: ElementAspectProps): void;
        updateElement<T extends ElementProps>(elProps: Partial<T>): void;
    }
    // (undocumented)
    export interface GuidMapper {
        // (undocumented)
        getFederationGuidFromId(id: Id64String): GuidString | undefined;
        // (undocumented)
        getIdFromFederationGuid(guid?: GuidString): Id64String | undefined;
    }
    // @preview
    export class Models {
        // @internal (undocumented)
        readonly [_cache]: LRUMap<string, ModelProps>;
        // @internal (undocumented)
        readonly [_instanceKeyCache]: InstanceKeyLRUCache;
        // @internal
        constructor(_iModel: IModelDb);
        createModel<T extends Model>(modelProps: ModelProps): T;
        deleteModel(ids: Id64Arg): void;
        getModel<T extends Model>(modelId: Id64String, modelClass?: EntityClassType<Model>): T;
        getModelProps<T extends ModelProps>(id: Id64String): T;
        getSubModel<T extends Model>(modeledElementId: Id64String | GuidString | Code, modelClass?: EntityClassType<Model>): T;
        insertModel(props: ModelProps): Id64String;
        queryExtents(ids: Id64String | Id64String[]): Promise<ModelExtentsProps[]>;
        queryLastModifiedTime(modelId: Id64String): string;
        queryRange(ids: Id64String | Id64String[]): Promise<AxisAlignedBox3d>;
        tryGetModel<T extends Model>(modelId: Id64String, modelClass?: EntityClassType<Model>): T | undefined;
        tryGetModelProps<T extends ModelProps>(id: Id64String): T | undefined;
        tryGetSubModel<T extends Model>(modeledElementId: Id64String | GuidString | Code, modelClass?: EntityClassType<Model>): T | undefined;
        updateGeometryGuid(modelId: Id64String): void;
        updateModel(props: UpdateModelOptions): void;
    }
    // @internal
    export enum TileContentState {
        // (undocumented)
        Loading = 2,// Request was just created and enqueued.
        // (undocumented)
        New = 0,// Request is enqueued but not yet being processed.
        // (undocumented)
        Pending = 1
    }
    // @internal (undocumented)
    export class Tiles {
        constructor(_iModel: IModelDb);
        // (undocumented)
        getTileContent(treeId: string, tileId: string): Promise<Uint8Array>;
        // (undocumented)
        requestTileContent(treeId: string, tileId: string): Promise<IModelJsNative.TileContent>;
        // (undocumented)
        requestTileTreeProps(id: string): Promise<IModelTileTreeProps>;
    }
    // @preview
    export class Views {
        // @internal
        constructor(_iModel: IModelDb);
        // @beta (undocumented)
        accessViewStore(args: {
            props?: CloudSqlite.ContainerProps;
            accessLevel?: BlobContainer.RequestAccessLevel;
        }): Promise<ViewStore.CloudAccess>;
        static readonly defaultQueryParams: ViewQueryParams;
        getThumbnail(viewDefinitionId: Id64String): ThumbnailProps | undefined;
        getViewStateProps(viewDefinitionId: ViewIdString, options?: ViewStateLoadProps): Promise<ViewStateProps>;
        // (undocumented)
        get hasViewStore(): boolean;
        iterateViews(params: ViewQueryParams, callback: (view: ViewDefinition) => boolean): boolean;
        queryViewDefinitionProps(className?: string, limit?: number, offset?: number, wantPrivate?: boolean): ViewDefinitionProps[];
        // @beta (undocumented)
        saveDefaultViewStore(arg: CloudSqlite.ContainerProps): void;
        saveThumbnail(viewDefinitionId: Id64String, thumbnail: ThumbnailProps): number;
        // @deprecated
        setDefaultViewId(viewId: Id64String): void;
        // @beta (undocumented)
        get viewStore(): ViewStore.CloudAccess;
        set viewStore(viewStore: ViewStore.CloudAccess);
    }
}

// @beta
export interface IModelDbFonts {
    // @internal (undocumented)
    readonly [_implementationProhibited]: unknown;
    acquireId(descriptor: FontFamilyDescriptor): Promise<FontId>;
    embedFontFile(args: EmbedFontFileArgs): Promise<void>;
    findDescriptor(id: FontId): FontFamilyDescriptor | undefined;
    findId(selector: FontFamilySelector): FontId | undefined;
    queryEmbeddedFontFiles(): Iterable<FontFile>;
    queryMappedFamilies(args?: QueryMappedFamiliesArgs): Iterable<FontProps>;
}

// @beta
export class IModelElementCloneContext {
    [Symbol.dispose](): void;
    constructor(sourceDb: IModelDb, targetDb?: IModelDb);
    // @internal
    cloneElement(sourceElement: Element_2, cloneOptions?: IModelJsNative.CloneElementOptions): Promise<ElementProps>;
    static create(...args: ConstructorParameters<typeof IModelElementCloneContext>): Promise<IModelElementCloneContext>;
    // @deprecated (undocumented)
    dispose(): void;
    // @internal
    dump(outputFileName: string): void;
    filterSubCategory(sourceSubCategoryId: Id64String): void;
    findTargetCodeSpecId(sourceId: Id64String): Id64String;
    findTargetElementId(sourceElementId: Id64String): Id64String;
    get hasSubCategoryFilter(): boolean;
    // @internal
    importCodeSpec(sourceCodeSpecId: Id64String): void;
    // @internal
    importFont(sourceFontNumber: number): void;
    initialize(): Promise<void>;
    get isBetweenIModels(): boolean;
    isSubCategoryFiltered(subCategoryId: Id64String): boolean;
    // @internal
    loadStateFromDb(db: SQLiteDb): void;
    remapCodeSpec(sourceCodeSpecName: string, targetCodeSpecName: string): void;
    remapElement(sourceId: Id64String, targetId: Id64String): void;
    remapElementClass(sourceClassFullName: string, targetClassFullName: string): void;
    removeElement(sourceId: Id64String): void;
    // @internal
    saveStateToDb(db: SQLiteDb): void;
    readonly sourceDb: IModelDb;
    readonly targetDb: IModelDb;
}

// @public
export class IModelHost {
    // @internal
    static [_getHubAccess](): BackendHubAccess | undefined;
    // @internal
    static get [_hubAccess](): BackendHubAccess;
    // @internal (undocumented)
    static [_setHubAccess](hubAccess: BackendHubAccess | undefined): void;
    static get appAssetsDir(): string | undefined;
    static get applicationId(): string;
    static set applicationId(id: string);
    static get applicationVersion(): string;
    static set applicationVersion(version: string);
    // @beta
    static get appWorkspace(): Workspace;
    static authorizationClient?: AuthorizationClient;
    // (undocumented)
    static backendVersion: string;
    static get cacheDir(): LocalDirName;
    // @internal
    static get compressCachedTiles(): boolean;
    // @internal (undocumented)
    static computeSchemaChecksum(arg: {
        schemaXmlPath: string;
        referencePaths: string[];
        exactMatch?: boolean;
    }): string;
    // (undocumented)
    static configuration?: Omit<IModelHostOptions, "hubAccess">;
    static createNewIModel(arg: CreateNewIModelProps): Promise<GuidString>;
    static getAccessToken(): Promise<AccessToken>;
    // @internal
    static getCrashReportProperties(): CrashReportingConfigNameValuePair[];
    static get isValid(): boolean;
    static get logTileLoadTimeThreshold(): number;
    static get logTileSizeThreshold(): number;
    static readonly onAfterStartup: BeEvent<() => void>;
    static readonly onBeforeShutdown: BeEvent<() => void>;
    static readonly onWorkspaceStartup: BeEvent<() => void>;
    // @beta
    static get profileDir(): LocalDirName;
    // @beta
    static get profileName(): string;
    // @internal
    static removeCrashReportProperty(name: string): void;
    // @internal
    static get restrictTileUrlsByClientIp(): boolean;
    // @internal (undocumented)
    static readonly session: Mutable<SessionProps>;
    static get sessionId(): GuidString;
    static set sessionId(id: GuidString);
    // @internal
    static setCrashReportProperty(name: string, value: string): void;
    // @beta
    static get settingsSchemas(): SettingsSchemas;
    static shutdown(this: void): Promise<void>;
    // @deprecated
    static snapshotFileNameResolver?: FileNameResolver;
    static startup(options?: IModelHostOptions): Promise<void>;
    // @internal
    static get tileContentRequestTimeout(): number;
    // @internal (undocumented)
    static tileStorage?: TileStorage;
    // @internal
    static get tileTreeRequestTimeout(): number;
    static userMoniker: string;
    // @internal
    static get useSemanticRebase(): boolean;
    // @internal
    static get usingExternalTileCache(): boolean;
}

// @public
export class IModelHostConfiguration implements IModelHostOptions {
    // (undocumented)
    appAssetsDir?: LocalDirName;
    authorizationClient?: AuthorizationClient;
    // (undocumented)
    cacheDir?: LocalDirName;
    // (undocumented)
    compressCachedTiles?: boolean;
    // @internal (undocumented)
    crashReportingConfig?: CrashReportingConfig;
    // (undocumented)
    static defaultLogTileLoadTimeThreshold: number;
    // (undocumented)
    static defaultLogTileSizeThreshold: number;
    // @internal (undocumented)
    static defaultMaxTileCacheDbSize: number;
    // (undocumented)
    static defaultTileRequestTimeout: number;
    // @beta
    disableRestorePointOnPullMerge?: true;
    // @beta
    disableThinnedNativeInstanceWorkflow?: boolean;
    // (undocumented)
    hubAccess?: BackendHubAccess;
    // @beta
    incrementalSchemaLoading: "enabled" | "disabled";
    // @internal (undocumented)
    logTileLoadTimeThreshold: number;
    // @internal (undocumented)
    logTileSizeThreshold: number;
    // @beta (undocumented)
    restrictTileUrlsByClientIp?: boolean;
    // @beta (undocumented)
    tileCacheAzureCredentials?: AzureBlobStorageCredentials;
    // @internal (undocumented)
    tileContentRequestTimeout: number;
    // @internal (undocumented)
    tileTreeRequestTimeout: number;
    // @beta
    useSemanticRebase?: boolean;
    // @beta (undocumented)
    workspace?: WorkspaceOpts;
}

// @public
export interface IModelHostOptions {
    allowSharedChannel?: boolean;
    appAssetsDir?: LocalDirName;
    authorizationClient?: AuthorizationClient;
    cacheDir?: LocalDirName;
    compressCachedTiles?: boolean;
    // @internal
    crashReportingConfig?: CrashReportingConfig;
    // @beta
    disableRestorePointOnPullMerge?: true;
    disableThinnedNativeInstanceWorkflow?: boolean;
    enableOpenTelemetry?: boolean;
    hubAccess?: BackendHubAccess;
    // @beta
    incrementalSchemaLoading?: "enabled" | "disabled";
    // @internal
    logTileLoadTimeThreshold?: number;
    // @internal
    logTileSizeThreshold?: number;
    // @beta
    maxTileCacheDbSize?: number;
    // @beta
    profileName?: string;
    // @beta
    restrictTileUrlsByClientIp?: boolean;
    // @beta
    tileCacheAzureCredentials?: AzureBlobStorageCredentials;
    // @beta
    tileCacheStorage?: ServerStorage;
    // @internal
    tileContentRequestTimeout?: number;
    // @internal
    tileTreeRequestTimeout?: number;
    // @beta
    useSemanticRebase?: boolean;
    // @beta
    workspace?: WorkspaceOpts;
}

// @public
export interface IModelIdArg extends TokenArg {
    // (undocumented)
    readonly iModelId: GuidString;
}

// @public
export class IModelJsFs {
    static appendFileSync(pathname: string, str: string): void;
    static copySync(src: string, dest: string, opts?: any): void;
    static existsSync(pathname: string): boolean;
    static lstatSync(pathname: string): IModelJsFsStats | undefined;
    static mkdirSync(pathname: string): void;
    static purgeDirSync(dirPath: string): void;
    static readdirSync(pathname: string): string[];
    static readFileSync(pathname: string): string | Buffer;
    static readFileWithEncodingSync(pathname: string, encoding: BufferEncoding): string;
    static recursiveFindSync(rootDir: string, pattern: RegExp): string[];
    static recursiveMkDirSync(dirPath: string): void;
    static removeSync(pathname: string): void;
    static rmdirSync(pathname: string): void;
    static unlinkSync(pathname: string): void;
    static walkDirSync(rootDir: string, cb: (pathname: string, isDir: boolean) => boolean): void;
    static writeFileSync(pathname: string, data: string | Uint8Array, wflag?: string): void;
}

// @public
export class IModelJsFsStats {
    constructor(size: number, atimeMs: number, mtimeMs: number, birthtimeMs: number, isDirectory: boolean, isFile: boolean, isSocket: boolean, isSymbolicLink: boolean, isReadOnly: boolean);
    // (undocumented)
    atimeMs: number;
    // (undocumented)
    birthtimeMs: number;
    // (undocumented)
    isDirectory: boolean;
    // (undocumented)
    isFile: boolean;
    // (undocumented)
    isReadOnly: boolean;
    // (undocumented)
    isSocket: boolean;
    // (undocumented)
    isSymbolicLink: boolean;
    // (undocumented)
    mtimeMs: number;
    // (undocumented)
    size: number;
}

export { IModelJsNative }

// @public
export interface IModelNameArg extends TokenArg, ITwinIdArg {
    // (undocumented)
    readonly iModelName: string;
}

// @internal
export class IModelNative {
    // (undocumented)
    static get platform(): typeof IModelJsNative;
}

// @public @preview
export abstract class InformationContentElement extends Element_2 {
    protected constructor(props: ElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class InformationModel extends Model {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class InformationPartitionElement extends InformationContentElement {
    protected constructor(props: InformationPartitionElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static createCode(iModel: IModelDb, parentSubjectId: CodeScopeProps, codeValue: string): Code;
    description?: string;
    // (undocumented)
    toJSON(): InformationPartitionElementProps;
}

// @public @preview
export abstract class InformationRecordElement extends InformationContentElement {
    protected constructor(props: ElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public @preview
export class InformationRecordModel extends InformationModel {
    // (undocumented)
    static get className(): string;
    static insert(iModelDb: IModelDb, parentSubjectId: Id64String, name: string): Id64String;
}

// @public @preview
export class InformationRecordPartition extends InformationPartitionElement {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class InformationReferenceElement extends InformationContentElement {
    protected constructor(props: ElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @internal (undocumented)
export function initializeTracing(enableOpenTelemetry?: boolean): void;

// @beta
export interface InlineGeometryPartsResult {
    numCandidateParts: number;
    numPartsDeleted: number;
    numRefsInlined: number;
}

// @public
export interface InsertElementOptions {
    // @beta
    forceUseId?: boolean;
}

// @beta
export interface InstanceChange {
    // (undocumented)
    changedInstance: {
        id: Id64String;
        className: string;
    };
    // (undocumented)
    id: Id64String;
    // (undocumented)
    isIndirect: boolean;
    // (undocumented)
    opCode: ChangeOpCode;
    // (undocumented)
    summaryId: Id64String;
}

// @internal
export interface InstancePatch {
    // (undocumented)
    isIndirect: boolean;
    // (undocumented)
    key: PatchInstanceKey;
    // (undocumented)
    op: "Inserted" | "Updated" | "Deleted";
    // (undocumented)
    props?: ECSqlRow;
}

// @beta
export interface IntegrityCheckOptions {
    quickCheck?: boolean;
    specificChecks?: {
        checkDataColumns?: boolean;
        checkECProfile?: boolean;
        checkNavigationClassIds?: boolean;
        checkNavigationIds?: boolean;
        checkLinktableForeignKeyClassIds?: boolean;
        checkLinktableForeignKeyIds?: boolean;
        checkClassIds?: boolean;
        checkDataSchema?: boolean;
        checkSchemaLoad?: boolean;
        checkMissingChildRows?: boolean;
    };
}

// @public
export abstract class IpcHandler {
    abstract get channelName(): string;
    static register(): RemoveFunction;
}

// @public
export class IpcHost {
    static addListener(channel: string, listener: IpcListener): RemoveFunction;
    static handle(channel: string, handler: (...args: any[]) => Promise<any>): RemoveFunction;
    static get isValid(): boolean;
    // (undocumented)
    static noStack: boolean;
    // @internal (undocumented)
    static notifyEditingScope<T extends keyof EditingScopeNotifications>(briefcase: BriefcaseDb | StandaloneDb, methodName: T, ...args: Parameters<EditingScopeNotifications[T]>): void;
    // @internal (undocumented)
    static notifyIpcFrontend<T extends keyof IpcAppNotifications>(methodName: T, ...args: Parameters<IpcAppNotifications[T]>): void;
    // @internal (undocumented)
    static notifyTxns<T extends keyof TxnNotifications>(briefcase: BriefcaseDb | StandaloneDb, methodName: T, ...args: Parameters<TxnNotifications[T]>): void;
    static removeListener(channel: string, listener: IpcListener): void;
    static send(channel: string, ...data: any[]): void;
    static shutdown(): Promise<void>;
    static startup(opt?: IpcHostOpts): Promise<void>;
}

// @public
export interface IpcHostOpts {
    // (undocumented)
    iModelHost?: IModelHostOptions;
    // (undocumented)
    ipcHost?: {
        socket?: IpcSocketBackend;
        exceptions?: {
            noStack?: boolean;
        };
    };
}

// @beta
export function isITextAnnotation(element: Element_2): element is ITextAnnotation & Element_2;

// @beta
export interface ITextAnnotation {
    defaultTextStyle?: TextAnnotationUsesTextStyleByDefault;
    getTextBlocks(): Iterable<TextBlockAndId>;
    updateTextBlocks(textBlocks: TextBlockAndId[]): void;
}

// @public
export interface ITwinIdArg {
    // (undocumented)
    readonly iTwinId: GuidString;
}

// @public
export class KnownLocations {
    static get nativeAssetsDir(): LocalDirName;
    static get packageAssetsDir(): LocalDirName;
    static get tmpdir(): LocalDirName;
}

// @beta
export interface LayoutTextArgs {
    // @internal
    computeTextRange?: ComputeRangesForTextLayout;
    // @internal
    findFontId?: FindFontId;
    iModel: IModelDb;
    textStyleResolver: TextStyleResolver;
}

// @beta
export function layoutTextBlock(args: LayoutTextBlockArgs): TextBlockLayout;

// @beta
export interface LayoutTextBlockArgs extends LayoutTextArgs {
    textBlock: TextBlock;
}

// @internal
export class LightLocation extends SpatialLocationElement {
    protected constructor(props: LightLocationProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    enabled?: boolean;
}

// @beta
export class LineLayout {
    constructor(source: List | Run | Paragraph, style: TextStyleSettingsProps, context?: LayoutContext, depth?: number);
    // (undocumented)
    append(run: RunLayout): void;
    get back(): RunLayout;
    // (undocumented)
    depth: number;
    get isEmpty(): boolean;
    // (undocumented)
    justificationRange: Range2d;
    // (undocumented)
    lengthFromLastTab: number;
    get marker(): RunLayout | undefined;
    set marker(value: RunLayout | undefined);
    // (undocumented)
    offsetFromDocument: WritableXAndY;
    // (undocumented)
    range: Range2d;
    // (undocumented)
    runRange: Range2d;
    get runs(): ReadonlyArray<RunLayout>;
    // (undocumented)
    source: List | Run | Paragraph;
    stringify(): string;
    // (undocumented)
    toResult(): LineLayoutResult;
}

// @public @preview
export class LineStyle extends DefinitionElement {
    protected constructor(props: LineStyleProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // (undocumented)
    data: string;
    // (undocumented)
    description?: string;
    // @beta
    static deserialize(props: DeserializeEntityArgs): LineStyleProps;
    // @beta
    static serialize(props: LineStyleProps, iModel: IModelDb): ECSqlRow;
}

// @public
export namespace LineStyleDefinition {
    export interface ComponentProps {
        id: number;
        offset?: number;
        type: ComponentType;
    }
    // (undocumented)
    export type Components = ComponentProps[];
    export enum ComponentType {
        Compound = 2,
        Internal = 6,
        PointSymbol = 1,
        RasterImage = 7,
        StrokePattern = 3,
        StrokePoint = 4
    }
    export interface CompoundProps {
        // (undocumented)
        comps: Components;
    }
    export enum PointSymbolFlags {
        Is3d = 1,
        None = 0,
        NoScale = 2
    }
    export interface PointSymbolProps {
        baseX?: number;
        baseY?: number;
        baseZ?: number;
        geomPartId: Id64String;
        scale?: number;
        sizeX?: number;
        sizeY?: number;
        sizeZ?: number;
        symFlags?: PointSymbolFlags;
    }
    export interface RasterImageProps {
        descr: string;
        flags?: number;
        imageId?: number;
        trueWidth?: number;
        x: number;
        y: number;
    }
    export enum StrokeCap {
        Arc = 30,
        Closed = 0,
        Decagon = 5,
        Extended = 2,
        Hexagon = 3,
        Octagon = 4,
        Open = 1
    }
    export enum StrokeMode {
        Dash = 1,
        FirstInvert = 8,
        Gap = 0,
        LastInvert = 16,
        Ray = 2,
        Scale = 4
    }
    export enum StrokePatternOptions {
        AutoPhase = 1,
        CenterStretch = 32,
        Iteration = 8,
        None = 0,
        Segment = 16
    }
    export interface StrokePatternProps {
        descr: string;
        maxIter?: number;
        options?: StrokePatternOptions;
        phase?: number;
        strokes: Strokes;
    }
    export interface StrokePointProps {
        descr: string;
        lcId: number;
        lcType?: ComponentType;
        symbols: Symbols;
    }
    export interface StrokeProps {
        capMode?: StrokeCap;
        endWidth?: number;
        length: number;
        orgWidth?: number;
        strokeMode?: StrokeMode;
        widthMode?: StrokeWidth;
    }
    // (undocumented)
    export type Strokes = StrokeProps[];
    export enum StrokeWidth {
        Full = 3,
        Left = 1,
        None = 0,
        Right = 2
    }
    export enum StyleFlags {
        Continuous = 8,
        None = 0,
        NoSnap = 4,
        Physical = 128
    }
    export interface StyleProps {
        compId: number;
        compType: ComponentType;
        flags?: StyleFlags;
        unitDef?: number;
    }
    export enum SymbolOptions {
        AbsoluteRotation = 64,
        AdjustRotation = 32,
        Center = 3,
        CurveEnd = 8,
        CurveOrigin = 4,
        CurveVertex = 16,
        End = 2,
        NoClip = 512,
        None = 0,
        NoPartial = 1024,
        NoScale = 256,
        Origin = 1,
        ProjectOrigin = 2048,
        UseColor = 16384,
        UseWeight = 32768
    }
    export interface SymbolProps {
        angle?: number;
        mod1?: SymbolOptions;
        strokeNum?: number;
        symId: number;
        symType?: ComponentType;
        xOffset?: number;
        yOffset?: number;
    }
    // (undocumented)
    export type Symbols = SymbolProps[];
    export class Utils {
        static createCompoundComponent(iModel: IModelDb, props: CompoundProps): StyleProps;
        static createPointSymbolComponent(iModel: IModelDb, props: PointSymbolProps): StyleProps | undefined;
        static createRasterComponent(iModel: IModelDb, props: RasterImageProps, image: Uint8Array): StyleProps | undefined;
        static createStrokePatternComponent(iModel: IModelDb, props: StrokePatternProps): StyleProps;
        static createStrokePointComponent(iModel: IModelDb, props: StrokePointProps): StyleProps;
        static createStyle(imodel: IModelDb, scopeModelId: Id64String, name: string, props: StyleProps): Id64String;
        static getOrCreateContinuousStyle(imodel: IModelDb, scopeModelId: Id64String, width?: number): Id64String;
        static getOrCreateLinePixelsStyle(imodel: IModelDb, scopeModelId: Id64String, linePixels: LinePixels): Id64String;
        static queryStyle(imodel: IModelDb, scopeModelId: Id64String, name: string): Id64String | undefined;
    }
}

// @public @preview
export abstract class LinkElement extends InformationReferenceElement {
    // (undocumented)
    static get className(): string;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
}

// @public @preview
export class LinkModel extends InformationModel {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export class LinkPartition extends InformationPartitionElement {
    // (undocumented)
    static get className(): string;
}

// @internal (undocumented)
export class LocalhostIpcHost {
    // (undocumented)
    static connect(connection: ws): void;
    // (undocumented)
    static socket: IpcWebSocketBackend;
    // (undocumented)
    static startup(opts?: {
        localhostIpcHost?: LocalhostIpcHostOpts;
        iModelHost?: IModelHostOptions;
    }): Promise<void>;
}

// @internal (undocumented)
export interface LocalhostIpcHostOpts {
    // (undocumented)
    host?: string;
    // (undocumented)
    noServer?: boolean;
    // (undocumented)
    socketPort?: number;
}

// @internal
export class LocalHub {
    constructor(rootDir: LocalDirName, arg: LocalHubProps);
    // (undocumented)
    acquireLock(props: LockProps, briefcase: BriefcaseIdAndChangeset): void;
    acquireLocks(locks: LockMap, briefcase: BriefcaseIdAndChangeset): void;
    acquireNewBriefcaseId(user: string, alias?: string): BriefcaseId;
    addChangeset(changeset: ChangesetFileProps): ChangesetIndex;
    addNamedVersion(arg: {
        versionName: string;
        csIndex: ChangesetIndex;
    }): void;
    // (undocumented)
    get changesetDir(): string;
    // (undocumented)
    get checkpointDir(): string;
    // (undocumented)
    checkpointNameFromIndex(csIndex: ChangesetIndex): string;
    // (undocumented)
    cleanup(): void;
    // (undocumented)
    countLocks(): number;
    // (undocumented)
    countSharedLocks(): number;
    deleteNamedVersion(versionName: string): void;
    // (undocumented)
    readonly description?: string;
    downloadChangeset(arg: {
        index: ChangesetIndex;
        targetDir: LocalDirName;
    }): ChangesetFileProps;
    downloadChangesets(arg: {
        range?: ChangesetRange;
        targetDir: LocalDirName;
    }): ChangesetFileProps[];
    downloadCheckpoint(arg: {
        changeset: ChangesetIndexOrId;
        targetFile: LocalFileName;
    }): {
        index: number;
        id: string;
    };
    findNamedVersion(versionName: string): ChangesetProps;
    // (undocumented)
    getBriefcase(id: BriefcaseId): MockBriefcaseIdProps;
    getBriefcaseIds(user: string): BriefcaseId[];
    getBriefcases(onlyAssigned?: boolean): MockBriefcaseIdProps[];
    getChangesetById(id: ChangesetId): ChangesetProps;
    getChangesetByIndex(index: ChangesetIndex): ChangesetProps;
    // (undocumented)
    getChangesetId(index: ChangesetIndex): ChangesetId;
    getChangesetIndex(id: ChangesetId): ChangesetIndex;
    getCheckpoints(range?: ChangesetRange): ChangesetIndex[];
    // (undocumented)
    getIndexFromChangeset(changeset: ChangesetIndexOrId): ChangesetIndex;
    // (undocumented)
    getLatestChangeset(): ChangesetProps;
    // (undocumented)
    getParentId(index: ChangesetIndex): ChangesetId;
    // (undocumented)
    getPreviousIndex(index: ChangesetIndex): number;
    // (undocumented)
    readonly iModelId: GuidString;
    // (undocumented)
    readonly iModelName: string;
    // (undocumented)
    readonly iTwinId: GuidString;
    // (undocumented)
    get latestChangesetIndex(): number;
    // (undocumented)
    get mockDbName(): string;
    // (undocumented)
    queryAllLocks(briefcaseId: BriefcaseId): LockProps[];
    // (undocumented)
    queryAllSharedLocks(): {
        id: Id64String;
        briefcaseId: BriefcaseId;
    }[];
    queryChangesets(range?: ChangesetRange): ChangesetProps[];
    // (undocumented)
    queryLocks(): LocksEntry[];
    // (undocumented)
    queryLockStatus(elementId: Id64String): LockStatus;
    queryPreviousCheckpoint(changesetIndex: ChangesetIndex): ChangesetIndex;
    // (undocumented)
    releaseAllLocks(arg: {
        briefcaseId: BriefcaseId;
        changesetIndex: ChangesetIndex;
    }): void;
    releaseBriefcaseId(id: BriefcaseId): void;
    // (undocumented)
    releaseLocks(locks: LockProps[], arg: {
        briefcaseId: BriefcaseId;
        changesetIndex: ChangesetIndex;
    }): void;
    // (undocumented)
    removeDir(dirName: string): void;
    // (undocumented)
    readonly rootDir: LocalDirName;
    uploadCheckpoint(arg: {
        changesetIndex: ChangesetIndex;
        localFile: LocalFileName;
    }): string;
}

// @beta
export class LockConflict extends IModelError {
    constructor(
    briefcaseId: BriefcaseId,
    briefcaseAlias: string, msg: "shared lock is held" | "exclusive lock is already held");
    readonly briefcaseAlias: string;
    readonly briefcaseId: BriefcaseId;
}

// @public
export interface LockControl {
    // @internal
    [_close]: () => void;
    // @internal
    [_elementWasCreated]: (id: Id64String) => void;
    // @internal (undocumented)
    readonly [_implementationProhibited]: unknown;
    // @internal
    [_releaseAllLocks]: () => Promise<void>;
    acquireLocks(arg: {
        shared?: Id64Arg;
        exclusive?: Id64Arg;
    }): Promise<void>;
    checkExclusiveLock(id: Id64String, type: string, operation: string): void;
    checkSharedLock(id: Id64String, type: string, operation: string): void;
    holdsExclusiveLock(id: Id64String): boolean;
    holdsSharedLock(id: Id64String): boolean;
    readonly isServerBased: boolean;
    releaseAllLocks(): Promise<void>;
}

// @public
export type LockMap = Map<Id64String, LockState_2>;

// @public
export interface LockProps {
    readonly id: Id64String;
    readonly state: LockState_2;
}

// @public @deprecated
export enum LockState {
    Exclusive = 2,
    None = 0,
    Shared = 1
}

// @internal
export interface LockStatusExclusive {
    // (undocumented)
    briefcaseId: BriefcaseId;
    // (undocumented)
    lastCsIndex?: ChangesetIndex;
    // (undocumented)
    state: LockState_2.Exclusive;
}

// @internal
export interface LockStatusShared {
    // (undocumented)
    lastCsIndex?: ChangesetIndex;
    // (undocumented)
    sharedBy: Set<BriefcaseId>;
    // (undocumented)
    state: LockState_2.Shared;
}

// @internal @deprecated
export class MetaDataRegistry {
    add(classFullName: string, metaData: EntityMetaData): void;
    find(classFullName: string): EntityMetaData | undefined;
    // (undocumented)
    findByClassId(classId: Id64String): EntityMetaData | undefined;
}

// @internal (undocumented)
export interface MockCheckpoint {
    // (undocumented)
    mockAttach(checkpoint: CheckpointProps): string;
    // (undocumented)
    mockDownload(_request: DownloadRequest): void;
}

// @public @preview
export class Model extends Entity {
    protected constructor(props: ModelProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    delete(): void;
    // @beta
    static deserialize(props: DeserializeEntityArgs): ModelProps;
    // (undocumented)
    getJsonProperty(name: string): any;
    getUserProperties(namespace: string): any;
    insert(): string;
    // (undocumented)
    isPrivate: boolean;
    // (undocumented)
    isTemplate: boolean;
    // (undocumented)
    readonly jsonProperties: {
        [key: string]: any;
    };
    // (undocumented)
    readonly modeledElement: RelatedElement;
    // (undocumented)
    readonly name: string;
    // @beta
    protected static onDelete(arg: OnModelIdArg): void;
    // @beta
    protected static onDeleted(arg: OnModelIdArg): void;
    // @beta
    protected static onDeletedElement(arg: OnElementInModelIdArg): void;
    // @beta
    protected static onDeleteElement(_arg: OnElementInModelIdArg): void;
    // @beta
    protected static onInsert(arg: OnModelPropsArg): void;
    // @beta
    protected static onInserted(_arg: OnModelIdArg): void;
    // @beta
    protected static onInsertedElement(arg: OnElementInModelIdArg): void;
    // @beta
    protected static onInsertElement(_arg: OnElementInModelPropsArg): void;
    // @beta
    protected static onUpdate(arg: OnModelPropsArg): void;
    // @beta
    protected static onUpdated(arg: OnModelIdArg): void;
    // @beta
    protected static onUpdatedElement(arg: OnElementInModelIdArg): void;
    // @beta
    protected static onUpdateElement(_arg: OnElementInModelPropsArg): void;
    // (undocumented)
    readonly parentModel?: Id64String;
    // @internal (undocumented)
    static get protectedOperations(): string[];
    removeUserProperties(nameSpace: string): void;
    // @beta
    static serialize(props: ModelProps, _iModel: IModelDb): ECSqlRow;
    // (undocumented)
    setJsonProperty(name: string, value: any): void;
    setUserProperties(nameSpace: string, value: any): void;
    // (undocumented)
    toJSON(): ModelProps;
    update(): void;
}

// @public @preview
export class ModelSelector extends DefinitionElement {
    protected constructor(props: ModelSelectorProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    static create(iModelDb: IModelDb, definitionModelId: Id64String, name: string, models: Id64Array): ModelSelector;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // @beta
    static deserialize(props: DeserializeEntityArgs): ModelSelectorProps;
    static insert(iModelDb: IModelDb, definitionModelId: Id64String, name: string, models: Id64Array): Id64String;
    models: Id64String[];
    // (undocumented)
    toJSON(): ModelSelectorProps;
}

// @internal
export class ModelSelectorRefersToModels extends Relationship {
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
}

// @public
export class NativeAppStorage {
    close(deleteFile?: boolean): void;
    // @internal
    static closeAll(): void;
    static find(name: string): NativeAppStorage;
    getBoolean(key: string): boolean | undefined;
    getData(key: string): StorageValue;
    getKeys(): string[];
    getNumber(key: string): number | undefined;
    // @internal (undocumented)
    static getStorageNames(): string[];
    getString(key: string): string | undefined;
    getUint8Array(key: string): Uint8Array | undefined;
    getValueType(key: string): "number" | "string" | "boolean" | "Uint8Array" | "null" | undefined;
    hasNullValue(key: string): boolean;
    // (undocumented)
    readonly id: string;
    static open(name: string): NativeAppStorage;
    removeAll(): void;
    removeData(key: string): void;
    setData(key: string, value: StorageValue): void;
}

export { NativeCloudSqlite }

// @internal (undocumented)
export const _nativeDb: unique symbol;

// @public
export class NativeHost {
    // (undocumented)
    static get applicationName(): string;
    static get appSettingsCacheDir(): string;
    static checkInternetConnectivity(): InternetConnectivityStatus;
    // (undocumented)
    static get isValid(): boolean;
    static notifyNativeFrontend<T extends keyof NativeAppNotifications>(methodName: T, ...args: Parameters<NativeAppNotifications[T]>): void;
    static readonly onInternetConnectivityChanged: BeEvent<(status: InternetConnectivityStatus) => void>;
    // @internal
    static overrideInternetConnectivity(_overridenBy: OverriddenBy, status: InternetConnectivityStatus): void;
    static get settingsStore(): NativeAppStorage;
    static shutdown(): Promise<void>;
    static startup(opt?: NativeHostOpts): Promise<void>;
}

// @public
export interface NativeHostOpts extends IpcHostOpts {
    // (undocumented)
    nativeHost?: {
        applicationName?: string;
    };
}

export { NativeLoggerCategory }

// @beta
export interface OnAspectArg {
    iModel: IModelDb;
    model: Id64String;
}

// @beta
export interface OnAspectIdArg extends OnAspectArg {
    aspectId: Id64String;
}

// @beta
export interface OnAspectPropsArg extends OnAspectArg {
    props: Readonly<ElementAspectProps>;
}

// @beta
export interface OnChildElementArg extends OnElementArg {
    // (undocumented)
    parentId: Id64String;
}

// @beta
export interface OnChildElementIdArg extends OnChildElementArg {
    childId: Id64String;
}

// @beta
export interface OnChildElementPropsArg extends OnChildElementArg {
    childProps: Readonly<ElementProps>;
}

// @beta
export interface OnElementArg {
    iModel: IModelDb;
}

// @beta
export interface OnElementIdArg extends OnElementArg {
    federationGuid: GuidString;
    id: Id64String;
    model: Id64String;
}

// @beta
export interface OnElementInModelIdArg extends OnModelIdArg {
    elementId: Id64String;
}

// @beta
export interface OnElementInModelPropsArg extends OnModelIdArg {
    elementProps: Readonly<ElementProps>;
}

// @beta
export interface OnElementPropsArg extends OnElementArg {
    props: ElementProps;
}

// @beta
export interface OnModelArg {
    iModel: IModelDb;
}

// @beta
export interface OnModelIdArg extends OnModelArg {
    id: Id64String;
}

// @beta
export interface OnModelPropsArg extends OnModelArg {
    props: Readonly<ModelProps>;
}

// @beta
export interface OnSubModelIdArg extends OnElementArg {
    subModelId: Id64String;
}

// @beta
export interface OnSubModelPropsArg extends OnElementArg {
    subModelProps: ModelProps;
}

// @public
export type OpenBriefcaseArgs = OpenBriefcaseProps & CloudContainerArgs & OpenSqliteArgs;

// @public @preview
export class OrthographicViewDefinition extends SpatialViewDefinition {
    constructor(props: SpatialViewDefinitionProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static create(iModelDb: IModelDb, definitionModelId: Id64String, name: string, modelSelectorId: Id64String, categorySelectorId: Id64String, displayStyleId: Id64String, range: Range3d, standardView?: StandardViewIndex): OrthographicViewDefinition;
    static insert(iModelDb: IModelDb, definitionModelId: Id64String, name: string, modelSelectorId: Id64String, categorySelectorId: Id64String, displayStyleId: Id64String, range: Range3d, standardView?: StandardViewIndex): Id64String;
    setRange(range: Range3d): void;
}

// @internal
export function parseTextAnnotationData(json: string | undefined): VersionedJSON<TextAnnotationProps> | undefined;

// @beta
export class PartialECChangeUnifier implements Disposable {
    [Symbol.dispose](): void;
    constructor(_db: AnyDb, _cache?: ECChangeUnifierCache);
    appendFrom(adaptor: ChangesetECAdaptor): void;
    getInstanceCount(): number;
    get instances(): IterableIterator<ChangedECInstance>;
}

// @public @preview
export abstract class PhysicalElement extends SpatialElement {
    protected constructor(props: PhysicalElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    physicalMaterial?: RelatedElement;
    // (undocumented)
    toJSON(): PhysicalElementProps;
}

// @public
export class PhysicalElementAssemblesElements extends ElementOwnsChildElements {
    constructor(parentId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public
export class PhysicalElementFulfillsFunction extends ElementRefersToElements {
    // (undocumented)
    static get className(): string;
}

// @public
export class PhysicalElementIsOfPhysicalMaterial extends RelatedElement {
    constructor(id: Id64String);
    // (undocumented)
    static classFullName: string;
}

// @public
export class PhysicalElementIsOfType extends GeometricElement3dHasTypeDefinition {
    constructor(id: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public
export abstract class PhysicalMaterial extends DefinitionElement {
    // (undocumented)
    static get className(): string;
    static create<T extends PhysicalMaterial>(iModelDb: IModelDb, definitionModelId: CodeScopeProps, name: string): T;
    static createCode(iModel: IModelDb, definitionModelId: CodeScopeProps, name: string): Code;
}

// @public @preview
export class PhysicalModel extends SpatialModel {
    // (undocumented)
    static get className(): string;
    static insert(iModelDb: IModelDb, parentSubjectId: Id64String, name: string, isPlanProjection?: boolean): Id64String;
}

// @public
export class PhysicalObject extends PhysicalElement {
    constructor(props: PhysicalElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public @preview
export class PhysicalPartition extends InformationPartitionElement {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class PhysicalType extends TypeDefinitionElement {
    protected constructor(props: PhysicalTypeProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
    physicalMaterial?: RelatedElement;
    // (undocumented)
    toJSON(): PhysicalTypeProps;
}

// @public
export class PhysicalTypeIsOfPhysicalMaterial extends RelatedElement {
    constructor(id: Id64String);
    // (undocumented)
    static classFullName: string;
}

// @public
export class PlanCallout extends Callout {
    constructor(props: CalloutProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export class Platform {
    static get platformName(): "win32" | "linux" | "darwin" | "ios" | "android" | "uwp";
}

// @beta
export interface PostImportContext<T = any> {
    data?: T;
    iModel: IModelDb;
    resources: DataTransformationResources;
}

// @beta
export interface PreImportCallbackResult<T = any> {
    cachedData?: T;
    // (undocumented)
    transformStrategy: DataTransformationStrategy;
}

// @beta
export interface PreImportContext<T = any> {
    data?: T;
    iModel: IModelDb;
    schemaData: LocalFileName[] | string[];
}

// @internal
export interface ProcessChangesetOptions {
    // (undocumented)
    endChangesetId: string;
    // (undocumented)
    filterSpatial?: boolean;
    // (undocumented)
    relationshipCacheSize?: number;
    // (undocumented)
    rulesetDir?: string;
    // (undocumented)
    rulesetId: string;
    // (undocumented)
    startChangesetId: string;
    // (undocumented)
    tempDir?: string;
    // (undocumented)
    wantBoundingBoxes?: boolean;
    // (undocumented)
    wantChunkTraversal?: boolean;
    // (undocumented)
    wantParents?: boolean;
    // (undocumented)
    wantPropertyChecksums?: boolean;
    // (undocumented)
    wantRelationshipCaching?: boolean;
}

// @beta
export function produceTextBlockGeometry(layout: TextBlockLayout, documentTransform: Transform): TextBlockGeometryProps;

// @public
export type ProgressFunction = (loaded: number, total: number) => ProgressStatus;

// @public
export enum ProgressStatus {
    Abort = 1,
    Continue = 0
}

// @beta
export class ProjectInformationRecord extends InformationRecordElement {
    // (undocumented)
    static get className(): string;
    static create(args: ProjectInformationRecordCreateArgs): ProjectInformationRecord;
    // (undocumented)
    protected static onInsert(arg: OnElementPropsArg): void;
    projectInformation: ProjectInformation;
    // (undocumented)
    toJSON(): ProjectInformationRecordProps;
}

// @beta
export interface ProjectInformationRecordCreateArgs extends ProjectInformation {
    code?: Code;
    iModel: IModelDb;
    parentSubjectId: Id64String;
}

// @public @preview
export type PropertyHandler = (name: string, property: Property) => void;

// @beta (undocumented)
export namespace PropertyStore {
    export class CloudAccess extends CloudSqlite.DbAccess<PropertyDb> {
        constructor(props: CloudSqlite.ContainerAccessProps);
        static createNewContainer(args: CreateNewContainerProps): Promise<CloudSqlite.ContainerProps>;
        // @internal
        static initializeDb(args: {
            props: CloudSqlite.ContainerProps;
        }): Promise<void>;
    }
    // (undocumented)
    export interface CreateNewContainerProps {
        // (undocumented)
        metadata: Omit<BlobContainer.Metadata, "containerType">;
        // (undocumented)
        scope: BlobContainer.Scope;
    }
    export type IterationReturn = void | "stop";
    export type PropertyArray = {
        name: PropertyName;
        value: PropertyType;
    }[];
    export class PropertyDb extends VersionedSqliteDb {
        // (undocumented)
        protected createDDL(): void;
        deleteProperties(propNames: PropertyName[]): Promise<void>;
        deleteProperty(propName: PropertyName): Promise<void>;
        forAllProperties(iter: PropertyIteration, filter?: PropertyFilter): void;
        getBlob(name: PropertyName): Uint8Array | undefined;
        getBlob(name: PropertyName, defaultValue: Uint8Array): Uint8Array;
        getBoolean(name: PropertyName): boolean | undefined;
        getBoolean(name: PropertyName, defaultValue: boolean): boolean;
        getNumber(name: PropertyName): number | undefined;
        getNumber(name: PropertyName, defaultValue: number): number;
        getObject(name: PropertyName): SettingsContainer | undefined;
        getObject(name: PropertyName, defaultValue: SettingsContainer): SettingsContainer;
        getProperty(name: PropertyName): PropertyType | undefined;
        getString(name: PropertyName, defaultValue: string): string;
        getString(name: PropertyName): string | undefined;
        // (undocumented)
        readonly myVersion = "3.0.0";
        saveProperties(props: PropertyArray): Promise<void>;
        saveProperty(name: PropertyName, value: PropertyType): Promise<void>;
    }
    export interface PropertyFilter {
        readonly orderBy?: "ASC" | "DESC";
        readonly sqlExpression?: string;
        readonly value?: string;
        readonly valueCompare?: "GLOB" | "LIKE" | "NOT GLOB" | "NOT LIKE" | "=" | "!=" | "<" | ">";
    }
    export type PropertyIteration = (name: string) => IterationReturn;
    export type PropertyName = string;
    export type PropertyType = string | number | boolean | Uint8Array | SettingsContainer;
}

// @public
export type PullChangesArgs = ToChangesetArgs & {
    onProgress?: ProgressFunction;
    noFastForward?: true;
};

// @public
export interface PushChangesArgs extends TokenArg {
    description: string;
    mergeRetryCount?: number;
    mergeRetryDelay?: BeDuration;
    // @internal @deprecated
    noFastForward?: true;
    pushRetryCount?: number;
    pushRetryDelay?: BeDuration;
    retainLocks?: true;
}

// @beta
export interface QueryLocalChangesArgs {
    readonly includedClasses?: string[];
    readonly includeUnsavedChanges?: boolean;
}

// @beta
export interface QueryMappedFamiliesArgs {
    includeNonEmbedded?: boolean;
}

// @beta
export interface QueryWorkspaceResourcesArgs {
    callback: QueryWorkspaceResourcesCallback;
    dbs: WorkspaceDb[];
    nameCompare?: "GLOB" | "LIKE" | "NOT GLOB" | "NOT LIKE" | "=" | "<" | ">";
    namePattern?: string;
    type?: "string" | "blob";
}

// @beta
export type QueryWorkspaceResourcesCallback = (resources: Iterable<{
    name: string;
    db: WorkspaceDb;
}>) => void;

// @alpha
export interface RebaseHandler {
    recompute(txn: TxnProps): Promise<void>;
    shouldReinstate(txn: TxnProps): boolean;
}

// @alpha
export class RebaseManager {
    constructor(_iModel: BriefcaseDb | StandaloneDb);
    abort(): Promise<void>;
    addConflictHandler(args: {
        id: string;
        handler: (args: RebaseChangesetConflictArgs) => DbConflictResolution | undefined;
    }): void;
    canAbort(): boolean;
    inProgress(): boolean;
    get isAborting(): boolean;
    get isMerging(): boolean;
    get isRebasing(): boolean;
    // @internal (undocumented)
    notifyApplyIncomingChangesBegin(changes: ChangesetProps[]): void;
    // @internal (undocumented)
    notifyApplyIncomingChangesEnd(changes: ChangesetProps[]): void;
    // @internal (undocumented)
    notifyDownloadChangesetsBegin(): void;
    // @internal (undocumented)
    notifyDownloadChangesetsEnd(): void;
    // @internal (undocumented)
    notifyPullMergeBegin(changeset: ChangesetIdWithIndex): void;
    // @internal (undocumented)
    notifyPullMergeEnd(changeset: ChangesetIdWithIndex): void;
    // @internal (undocumented)
    notifyRebaseBegin(txns: TxnProps[]): void;
    // @internal (undocumented)
    notifyRebaseEnd(txns: TxnProps[]): void;
    // @internal (undocumented)
    notifyRebaseTxnBegin(txnProps: TxnProps): void;
    // @internal (undocumented)
    notifyRebaseTxnEnd(txnProps: TxnProps): void;
    // @internal (undocumented)
    notifyReverseLocalChangesBegin(): void;
    // @internal (undocumented)
    notifyReverseLocalChangesEnd(txns: TxnProps[]): void;
    readonly onApplyIncomingChangesBegin: BeEvent<(changesets: ChangesetProps[]) => void>;
    readonly onApplyIncomingChangesEnd: BeEvent<(changes: ChangesetProps[]) => void>;
    onConflict(args: RebaseChangesetConflictArgs): DbConflictResolution | undefined;
    readonly onDownloadChangesetsBegin: BeEvent<() => void>;
    readonly onDownloadChangesetsEnd: BeEvent<() => void>;
    readonly onPullMergeBegin: BeEvent<(changeset: ChangesetIdWithIndex) => void>;
    readonly onPullMergeEnd: BeEvent<(changeset: ChangesetIdWithIndex) => void>;
    readonly onRebaseBegin: BeEvent<(txns: TxnProps[]) => void>;
    readonly onRebaseEnd: BeEvent<(txns: TxnProps[]) => void>;
    readonly onRebaseTxnBegin: BeEvent<(txnProps: TxnProps) => void>;
    readonly onRebaseTxnEnd: BeEvent<(txnProps: TxnProps) => void>;
    readonly onReverseLocalChangesBegin: BeEvent<() => void>;
    readonly onReverseLocalChangesEnd: BeEvent<(txns: TxnProps[]) => void>;
    removeConflictHandler(id: string): void;
    resume(): Promise<void>;
    resumeSemantic(): Promise<void>;
    setCustomHandler(handler: RebaseHandler): void;
}

// @beta
export abstract class RecipeDefinitionElement extends DefinitionElement {
    protected constructor(props: ElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export class Relationship extends Entity {
    protected constructor(props: RelationshipProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    delete(): void;
    // (undocumented)
    static getInstance<T extends Relationship>(iModel: IModelDb, criteria: Id64String | SourceAndTarget): T;
    getMetaData(): Promise<RelationshipClass>;
    insert(): Id64String;
    static onDeletedDependency(_props: RelationshipProps, _iModel: IModelDb): void;
    static onRootChanged(_props: RelationshipProps, _iModel: IModelDb): void;
    // (undocumented)
    readonly sourceId: Id64String;
    // (undocumented)
    readonly targetId: Id64String;
    // (undocumented)
    toJSON(): RelationshipProps;
    update(): void;
}

export { RelationshipProps }

// @public
export class Relationships {
    // @internal
    constructor(iModel: IModelDb);
    createInstance(props: RelationshipProps): Relationship;
    deleteInstance(props: RelationshipProps): void;
    deleteInstances(props: ReadonlyArray<RelationshipProps>): void;
    getInstance<T extends Relationship>(relClassSqlName: string, criteria: Id64String | SourceAndTarget): T;
    getInstanceProps<T extends RelationshipProps>(relClassFullName: string, criteria: Id64String | SourceAndTarget): T;
    insertInstance(props: RelationshipProps): Id64String;
    tryGetInstance<T extends Relationship>(relClassFullName: string, criteria: Id64String | SourceAndTarget): T | undefined;
    tryGetInstanceProps<T extends RelationshipProps>(relClassFullName: string, criteria: Id64String | SourceAndTarget): T | undefined;
    updateInstance(props: RelationshipProps): void;
}

// @public
export class RenderMaterialElement extends DefinitionElement {
    // (undocumented)
    static get className(): string;
    static create(iModelDb: IModelDb, definitionModelId: Id64String, materialName: string, params: RenderMaterialElementParams): RenderMaterialElement;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, name: string): Code;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    description?: string;
    // @beta
    static deserialize(props: DeserializeEntityArgs): RenderMaterialProps;
    static insert(iModelDb: IModelDb, definitionModelId: Id64String, materialName: string, params: RenderMaterialElementParams): Id64String;
    // @beta (undocumented)
    protected static onCloned(context: IModelElementCloneContext, sourceProps: ElementProps, targetProps: ElementProps): Promise<void>;
    paletteName: string;
    // @beta
    static serialize(props: RenderMaterialProps, iModel: IModelDb): ECSqlRow;
    // (undocumented)
    toJSON(): RenderMaterialProps;
}

// @public (undocumented)
export namespace RenderMaterialElement {
    // @deprecated
    export class Params {
        constructor(paletteName: string);
        color?: RgbFactorProps;
        description?: string;
        diffuse?: number;
        finish?: number;
        normalMap?: NormalMapProps & {
            scale?: number;
        };
        paletteName: string;
        patternMap?: TextureMapProps;
        reflect?: number;
        reflectColor?: number[];
        specular?: number;
        specularColor?: RgbFactorProps;
        transmit?: number;
    }
}

// @public
export interface RenderMaterialElementParams extends RenderMaterialElement.Params {
}

// @public
export class RenderMaterialOwnsRenderMaterials extends ElementOwnsChildElements {
    constructor(parentId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @beta
export interface RenderPriority {
    // (undocumented)
    annotation?: number;
    // (undocumented)
    annotationLabels?: number;
}

// @public @preview
export class RenderTimeline extends InformationRecordElement {
    protected constructor(props: RenderTimelineProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(ids: EntityReferenceSet): void;
    description: string;
    // @beta
    static deserialize(props: DeserializeEntityArgs): RenderTimelineProps;
    // (undocumented)
    static fromJSON(props: RenderTimelineProps, iModel: IModelDb): RenderTimeline;
    // @alpha (undocumented)
    protected static onCloned(context: IModelElementCloneContext, sourceProps: RenderTimelineProps, targetProps: RenderTimelineProps): Promise<void>;
    // @beta
    static remapScript(context: IModelElementCloneContext, input: RenderSchedule.ScriptProps): RenderSchedule.ScriptProps;
    scriptProps: RenderSchedule.ScriptProps;
    // (undocumented)
    toJSON(): RenderTimelineProps;
}

// @public @preview
export class RepositoryLink extends UrlLink {
    protected constructor(props: RepositoryLinkProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    format?: string;
    // (undocumented)
    repositoryGuid?: GuidString;
    // (undocumented)
    toJSON(): RepositoryLinkProps;
}

// @public @preview
export class RepositoryModel extends DefinitionModel {
    // (undocumented)
    static get className(): string;
}

// @public
export interface RequestNewBriefcaseArg extends TokenArg, RequestNewBriefcaseProps {
    onProgress?: ProgressFunction;
}

// @public
export type RevertChangesArgs = Optional<PushChangesArgs, "description"> & {
    onProgress?: ProgressFunction;
    toIndex: ChangesetIndex;
    skipSchemaChanges?: true;
};

// @public @preview
export abstract class RoleElement extends Element_2 {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export class RoleModel extends Model {
    // (undocumented)
    static get className(): string;
}

// @public
export class RpcTrace {
    static get currentActivity(): RpcActivity | undefined;
    static get expectCurrentActivity(): RpcActivity;
    static run<T>(activity: RpcActivity, fn: () => Promise<T>): Promise<T>;
    static runWithSpan<T>(activity: RpcActivity, fn: () => Promise<T>): Promise<T>;
}

// @beta
export class RunLayout {
    // (undocumented)
    canWrap(): this is {
        source: TextRun;
    };
    // (undocumented)
    charOffset: number;
    // (undocumented)
    static create(source: Run, context: LayoutContext, cumulativeOverrides: TextStyleSettingsProps): RunLayout;
    // (undocumented)
    denominatorRange?: Range2d;
    // (undocumented)
    fontId: FontId;
    // (undocumented)
    justificationRange?: Range2d;
    // (undocumented)
    numChars: number;
    // (undocumented)
    numeratorRange?: Range2d;
    // (undocumented)
    offsetFromLine: {
        x: number;
        y: number;
    };
    // (undocumented)
    range: Range2d;
    // (undocumented)
    source: Run;
    // (undocumented)
    split(context: LayoutContext): RunLayout[];
    stringify(): string;
    // (undocumented)
    style: TextStyleSettings;
    // (undocumented)
    toResult(): RunLayoutResult;
}

// @public
export class Schema {
    // @internal
    protected constructor();
    // @internal
    static get missingRequiredBehavior(): boolean;
    // @internal
    static get schemaKey(): SchemaKey_2;
    static get schemaName(): string;
    // @beta
    static toSemverString(paddedVersion: string): string;
}

// @beta
export interface SchemaImportCallbacks<T = any> {
    postSchemaImportCallback?: (context: PostImportContext) => Promise<void>;
    preSchemaImportCallback?: (context: PreImportContext) => Promise<PreImportCallbackResult<T>>;
}

// @public
export interface SchemaImportOptions<T = any> {
    // @beta
    channelUpgrade?: ChannelUpgradeOptions;
    // @beta
    data?: T;
    // @internal
    ecSchemaXmlContext?: ECSchemaXmlContext;
    // @beta
    schemaImportCallbacks?: SchemaImportCallbacks;
}

// @internal (undocumented)
export type SchemaKey = IModelJsNative.ECSchemaXmlContext.SchemaKey;

// @public
export class SchemaMap {
    // @internal (undocumented)
    delete(schemaName: string): boolean;
    // @internal (undocumented)
    get(schemaName: string): typeof Schema | undefined;
    registerSchema(schema: typeof Schema): void;
    // @internal (undocumented)
    set(schemaName: string, schema: typeof Schema): void;
}

// @internal (undocumented)
export type SchemaMatchType = IModelJsNative.ECSchemaXmlContext.SchemaMatchType;

// @public
export class Schemas {
    static getRegisteredSchema(schemaName: string): typeof Schema | undefined;
    static registerSchema(schema: typeof Schema): void;
    static unregisterSchema(schemaName: string): boolean;
}

// @internal (undocumented)
export namespace SchemaSync {
    export class CloudAccess extends CloudSqlite.DbAccess<SchemaSyncDb> {
        constructor(props: CloudSqlite.ContainerAccessProps);
        // (undocumented)
        getUri(): string;
        static initializeDb(props: CloudSqlite.ContainerProps): Promise<void>;
    }
    const // (undocumented)
    setTestCache: (iModel: IModelDb, cacheName?: string) => void;
    const // (undocumented)
    withLockedAccess: (iModel: IModelDb | {
        readonly fileName: LocalFileName;
    }, args: {
        operationName: string;
        openMode?: OpenMode;
        user?: string;
    }, operation: (access: CloudAccess) => Promise<void>) => Promise<void>;
    const // (undocumented)
    withReadonlyAccess: (iModel: IModelDb | {
        readonly fileName: LocalFileName;
    }, operation: (access: CloudAccess) => Promise<void>) => Promise<void>;
    const // (undocumented)
    isEnabled: (iModel: IModelDb) => boolean;
    const pull: (iModel: IModelDb) => Promise<void>;
    const // (undocumented)
    initializeForIModel: (arg: {
        iModel: IModelDb;
        containerProps: CloudSqlite.ContainerProps;
        overrideContainer?: boolean;
    }) => Promise<void>;
    export class SchemaSyncDb extends VersionedSqliteDb {
        // (undocumented)
        protected createDDL(): void;
        // (undocumented)
        readonly myVersion = "4.0.0";
    }
}

// @public
export class SectionCallout extends Callout {
    constructor(props: CalloutProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public @preview
export class SectionDrawing extends Drawing {
    protected constructor(props: SectionDrawingProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    displaySpatialView: boolean;
    drawingBoundaryClip?: ClipVector;
    // (undocumented)
    protected static get drawingModelFullClassName(): string;
    drawingToSpatialTransform?: Transform;
    sectionType: SectionType;
    sheetToSpatialTransform?: Transform;
    spatialView: RelatedElement;
    // (undocumented)
    toJSON(): SectionDrawingProps;
}

// @public @preview
export class SectionDrawingLocation extends SpatialLocationElement {
    constructor(props: SectionDrawingLocationProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    sectionView: RelatedElement;
    // (undocumented)
    toJSON(): SectionDrawingLocationProps;
}

// @public @preview
export class SectionDrawingModel extends DrawingModel {
    // (undocumented)
    static get className(): string;
}

// @internal
export function setMaxEntitiesPerEvent(max: number): number;

// @beta
export type Setting = JSONSchemaType;

// @beta (undocumented)
export namespace Setting {
    export function areEqual(a: Setting | undefined, b: Setting | undefined): boolean;
    export function clone<T extends Setting>(setting: T): T;
}

// @beta
export interface SettingGroupSchema {
    readonly description: string;
    readonly order?: number;
    readonly schemaPrefix: string;
    readonly settingDefs?: {
        [name: string]: SettingSchema | undefined;
    };
    readonly typeDefs?: {
        [name: string]: SettingSchema | undefined;
    };
}

// @beta
export type SettingName = string;

// @beta
export interface Settings {
    // @internal (undocumented)
    [_implementationProhibited]: unknown;
    addDictionary(props: SettingsDictionaryProps, settings: SettingsContainer): void;
    addDirectory(directory: LocalDirName, priority: SettingsPriority): void;
    addFile(fileName: LocalFileName, priority: SettingsPriority): void;
    addJson(props: SettingsDictionaryProps, settingsJson: string): void;
    // @internal (undocumented)
    close(): void;
    readonly dictionaries: readonly SettingsDictionary[];
    dropDictionary(props: SettingsDictionarySource): void;
    getArray<T extends Setting>(settingName: SettingName, defaultValue: Array<T>): Array<T>;
    // (undocumented)
    getArray<T extends Setting>(settingName: SettingName): Array<T> | undefined;
    getBoolean(settingName: SettingName, defaultValue: boolean): boolean;
    // (undocumented)
    getBoolean(settingName: SettingName, defaultValue?: boolean): boolean | undefined;
    getDictionary(source: SettingsDictionarySource): SettingsDictionary | undefined;
    getNumber(settingName: SettingName, defaultValue: number): number;
    // (undocumented)
    getNumber(settingName: SettingName): number | undefined;
    getObject<T extends object>(settingName: SettingName, defaultValue: T): T;
    // (undocumented)
    getObject<T extends object>(settingName: SettingName): T | undefined;
    getSetting<T extends Setting>(settingName: SettingName, defaultValue?: T): T | undefined;
    getSettingEntries<T extends Setting>(settingName: SettingName): Iterable<{
        value: T;
        dictionary: SettingsDictionary;
    }>;
    getSettingValues<T extends Setting>(settingName: SettingName): Iterable<T>;
    getString(settingName: SettingName, defaultValue: string): string;
    // (undocumented)
    getString(settingName: SettingName, defaultValue?: string): string | undefined;
    readonly onSettingsChanged: BeEvent<() => void>;
}

// @beta
export interface SettingSchema extends Readonly<JSONSchema> {
    readonly combineArray?: boolean;
    readonly extends?: string;
    readonly items?: SettingSchema;
    readonly properties?: {
        [name: SettingName]: SettingSchema;
    };
    readonly type: JSONSchemaTypeName;
}

// @beta
export interface SettingsContainer {
    [name: SettingName]: Setting | undefined;
}

// @beta
export interface SettingsDictionary {
    // @internal (undocumented)
    [_implementationProhibited]: unknown;
    getSetting<T extends Setting>(settingName: SettingName): T | undefined;
    readonly props: SettingsDictionaryProps;
}

// @beta
export interface SettingsDictionaryProps extends SettingsDictionarySource {
    readonly priority: SettingsPriority;
}

// @beta
export interface SettingsDictionarySource {
    readonly name: string;
    readonly workspaceDb?: WorkspaceDb;
}

// @beta
export type SettingsPriority = number;

// @beta (undocumented)
export namespace SettingsPriority {
    const defaults = 100;
    const application = 200;
    const organization = 300;
    const iTwin = 400;
    const branch = 500;
    const iModel = 600;
}

// @beta
export interface SettingsSchemas {
    // @internal (undocumented)
    readonly [_implementationProhibited]: unknown;
    addDirectory(dirName: LocalDirName): void;
    addFile(fileName: LocalFileName): void;
    addGroup(settingsGroup: SettingGroupSchema | SettingGroupSchema[]): void;
    addJson(settingSchema: string): void;
    readonly onSchemaChanged: BeEvent<() => void>;
    removeGroup(schemaPrefix: string): void;
    readonly settingDefs: ReadonlyMap<SettingName, SettingSchema>;
    readonly typeDefs: ReadonlyMap<SettingName, SettingSchema>;
    validateSetting<T>(value: T, settingName: SettingName): T;
}

// @public @preview
export class Sheet extends Document_2 {
    protected constructor(props: SheetProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
    // (undocumented)
    height: number;
    // (undocumented)
    scale?: number;
    // (undocumented)
    sheetTemplate?: Id64String;
    // (undocumented)
    width: number;
}

// @public @preview
export class SheetBorderTemplate extends Document_2 {
    protected constructor(props: SheetBorderTemplateProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    height?: number;
    // (undocumented)
    width?: number;
}

// @beta
export class SheetIndex extends InformationReferenceElement {
    // (undocumented)
    static get className(): string;
    static create(iModelDb: IModelDb, modelId: Id64String, name: string): SheetIndex;
    static createCode(iModel: IModelDb, scopeSheetIndexModelId: CodeScopeProps, codeValue: string): Code;
    static insert(iModelDb: IModelDb, modelId: Id64String, name: string): Id64String;
}

// @beta
export abstract class SheetIndexEntry extends InformationReferenceElement {
    protected constructor(props: SheetIndexEntryProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static createCode(iModelDb: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
    // (undocumented)
    protected static createParentRelationshipProps(iModelDb: IModelDb, id: Id64String): RelatedElementProps;
    // (undocumented)
    protected static createProps(arg: SheetIndexEntryCreateArgs): SheetIndexEntryProps;
    entryPriority: number;
    // (undocumented)
    toJSON(): SheetIndexEntryProps;
}

// @beta
export interface SheetIndexEntryCreateArgs {
    iModelDb: IModelDb;
    name: string;
    parentId: Id64String;
    priority: number;
    sheetIndexModelId: Id64String;
}

// @beta
export class SheetIndexFolder extends SheetIndexEntry {
    // (undocumented)
    static get className(): string;
    static create(arg: SheetIndexEntryCreateArgs): SheetIndexFolder;
    static insert(arg: SheetIndexEntryCreateArgs): Id64String;
}

// @beta
export class SheetIndexFolderOwnsEntries extends ElementOwnsChildElements {
    constructor(parentId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @beta
export class SheetIndexModel extends InformationModel {
    // (undocumented)
    static get className(): string;
    static insert(iModelDb: IModelDb, parentSubjectId: Id64String, name: string): Id64String;
}

// @beta
export class SheetIndexOwnsEntries extends ElementOwnsChildElements {
    constructor(parentId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @beta
export class SheetIndexPartition extends InformationPartitionElement {
    // (undocumented)
    static get className(): string;
}

// @beta
export class SheetIndexReference extends SheetIndexEntry {
    protected constructor(props: SheetIndexReferenceProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // @alpha (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    static create(arg: SheetIndexReferenceCreateArgs): SheetIndexReference;
    // (undocumented)
    protected static createReferenceRelationshipProps(id: Id64String): RelatedElementProps;
    static insert(arg: SheetIndexReferenceCreateArgs): Id64String;
    sheetIndex?: SheetIndexReferenceRefersToSheetIndex;
    // (undocumented)
    toJSON(): SheetIndexReferenceProps;
}

// @beta
export interface SheetIndexReferenceCreateArgs extends SheetIndexEntryCreateArgs {
    sheetIndexId?: Id64String;
}

// @beta
export class SheetIndexReferenceRefersToSheetIndex extends RelatedElement {
    constructor(sheetIndexId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @beta
export class SheetInformationAspect extends ElementUniqueAspect {
    // (undocumented)
    static get className(): string;
    static getSheetInformation(sheetId: Id64String, iModel: IModelDb): SheetInformation | undefined;
    // (undocumented)
    protected static onInsert(arg: OnAspectPropsArg): void;
    static setSheetInformation(information: SheetInformation | undefined, sheetId: Id64String, iModel: IModelDb): void;
    sheetInformation: SheetInformation;
    // (undocumented)
    toJSON(): SheetInformationAspectProps;
}

// @public @preview
export class SheetModel extends GraphicalModel2d {
    // (undocumented)
    static get className(): string;
}

// @beta
export class SheetOwnsSheetInformationAspect extends ElementOwnsUniqueAspect {
    constructor(sheetId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @beta
export class SheetReference extends SheetIndexEntry {
    protected constructor(props: SheetReferenceProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // @alpha (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    static create(arg: SheetReferenceCreateArgs): SheetReference;
    // (undocumented)
    protected static createReferenceRelationshipProps(id: Id64String): RelatedElementProps;
    static insert(arg: SheetReferenceCreateArgs): Id64String;
    sheet: SheetReferenceRefersToSheet | undefined;
    // (undocumented)
    toJSON(): SheetReferenceProps;
}

// @beta
export interface SheetReferenceCreateArgs extends SheetIndexEntryCreateArgs {
    sheetId?: Id64String;
}

// @beta
export class SheetReferenceRefersToSheet extends RelatedElement {
    constructor(sheetId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public @preview
export class SheetTemplate extends Document_2 {
    protected constructor(props: SheetTemplateProps, iModel: IModelDb);
    // (undocumented)
    border?: Id64String;
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    // (undocumented)
    height?: number;
    // (undocumented)
    width?: number;
}

// @public @preview
export class SheetViewDefinition extends ViewDefinition2d {
    protected constructor(props: ViewDefinition2dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static create(args: CreateSheetViewDefinitionArgs): SheetViewDefinition;
    static fromJSON(props: Omit<ViewDefinition2dProps, "classFullName">, iModel: IModelDb): SheetViewDefinition;
    static insert(args: CreateSheetViewDefinitionArgs): Id64String;
}

// @beta
export interface SimplifyElementGeometryArgs {
    convertBReps?: boolean;
    id: Id64String;
}

// @public
export class SnapshotDb extends IModelDb {
    // @internal (undocumented)
    beforeClose(): void;
    static createEmpty(filePath: LocalFileName, options: CreateEmptySnapshotIModelProps): SnapshotDb;
    static createFrom(iModelDb: IModelDb, snapshotFile: string, options?: CreateSnapshotIModelProps): SnapshotDb;
    // (undocumented)
    static findByKey(key: string): SnapshotDb;
    // (undocumented)
    get isSnapshot(): boolean;
    // (undocumented)
    static readonly onOpen: BeEvent<(path: LocalFileName, opts?: SnapshotDbOpenArgs) => void>;
    // (undocumented)
    static readonly onOpened: BeEvent<(_iModelDb: SnapshotDb) => void>;
    // @beta
    static openCheckpoint(args: OpenCheckpointArgs): Promise<SnapshotDb>;
    // @internal (undocumented)
    static openCheckpointFromRpc(checkpoint: CheckpointProps): Promise<SnapshotDb>;
    static openFile(path: LocalFileName, opts?: SnapshotDbOpenArgs): SnapshotDb;
    // @internal
    static openForApplyChangesets(path: LocalFileName, props?: SnapshotDbOpenArgs): SnapshotDb;
    // @internal
    refreshContainerForRpc(userAccessToken: AccessToken): Promise<void>;
    // (undocumented)
    static tryFindByKey(key: string): SnapshotDb | undefined;
}

// @public
export type SnapshotDbOpenArgs = SnapshotOpenOptions & CloudContainerArgs & OpenSqliteArgs;

export { SourceAndTarget }

// @public @preview
export class SpatialCategory extends Category {
    protected constructor(opts: ElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static create(iModelDb: IModelDb, definitionModelId: Id64String, name: string): SpatialCategory;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
    static getCodeSpecName(): string;
    static insert(iModelDb: IModelDb, definitionModelId: Id64String, name: string, defaultAppearance: SubCategoryAppearance.Props | SubCategoryAppearance): Id64String;
    static queryCategoryIdByName(iModel: IModelDb, scopeModelId: Id64String, categoryName: string): Id64String | undefined;
}

// @public @preview
export abstract class SpatialElement extends GeometricElement3d {
    protected constructor(props: GeometricElement3dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export class SpatialLocation extends SpatialLocationElement {
    constructor(props: GeometricElement3dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class SpatialLocationElement extends SpatialElement {
    protected constructor(props: GeometricElement3dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export class SpatialLocationIsOfType extends GeometricElement3dHasTypeDefinition {
    constructor(id: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public @preview
export class SpatialLocationModel extends SpatialModel {
    // (undocumented)
    static get className(): string;
    static insert(iModelDb: IModelDb, parentSubjectId: Id64String, name: string, isPlanProjection?: boolean): Id64String;
}

// @public @preview
export class SpatialLocationPartition extends InformationPartitionElement {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class SpatialLocationType extends TypeDefinitionElement {
    protected constructor(props: TypeDefinitionElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
}

// @public @preview
export abstract class SpatialModel extends GeometricModel3d {
    // (undocumented)
    static get className(): string;
}

// @public @preview
export class SpatialViewDefinition extends ViewDefinition3d {
    protected constructor(props: SpatialViewDefinitionProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    static createWithCamera(iModelDb: IModelDb, definitionModelId: Id64String, name: string, modelSelectorId: Id64String, categorySelectorId: Id64String, displayStyleId: Id64String, range: Range3d, standardView?: StandardViewIndex, cameraAngle?: number): SpatialViewDefinition;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // @beta
    static deserialize(props: DeserializeEntityArgs): SpatialViewDefinitionProps;
    static fromJSON(props: Omit<SpatialViewDefinitionProps, "classFullName">, iModel: IModelDb): SpatialViewDefinition;
    static insertWithCamera(iModelDb: IModelDb, definitionModelId: Id64String, name: string, modelSelectorId: Id64String, categorySelectorId: Id64String, displayStyleId: Id64String, range: Range3d, standardView?: StandardViewIndex, cameraAngle?: number): Id64String;
    loadModelSelector(): ModelSelector;
    modelSelectorId: Id64String;
    // @beta (undocumented)
    static readonly requiredReferenceKeys: ReadonlyArray<string>;
    // @alpha (undocumented)
    static readonly requiredReferenceKeyTypeMap: Record<string, ConcreteEntityTypes>;
    // @beta
    static serialize(props: SpatialViewDefinitionProps, _iModel: IModelDb): ECSqlRow;
    // (undocumented)
    toJSON(): SpatialViewDefinitionProps;
}

// @beta
export interface SqliteChange {
    $op?: SqliteChangeOp;
    $stage?: SqliteValueStage;
    $table?: string;
    [key: string]: any;
}

// @beta
export type SqliteChangeOp = "Inserted" | "Updated" | "Deleted";

// @beta
export class SqliteChangesetReader implements Disposable {
    [Symbol.dispose](): void;
    protected constructor(
    db: AnyDb);
    get changeIndex(): number;
    close(): void;
    get columnCount(): number;
    readonly db: AnyDb;
    get disableSchemaCheck(): boolean;
    getChangeValue(columnIndex: number, stage: SqliteValueStage): SqliteValue_2;
    getChangeValueBinary(columnIndex: number, stage: SqliteValueStage): Uint8Array | null | undefined;
    getChangeValueDouble(columnIndex: number, stage: SqliteValueStage): number | null | undefined;
    getChangeValueId(columnIndex: number, stage: SqliteValueStage): Id64String | null | undefined;
    getChangeValueInteger(columnIndex: number, stage: SqliteValueStage): number | null | undefined;
    getChangeValuesArray(stage: SqliteValueStage): SqliteValueArray | undefined;
    getChangeValuesObject(stage: SqliteValueStage, args?: ChangeFormatArgs): SqliteChange | undefined;
    getChangeValueText(columnIndex: number, stage: SqliteValueStage): string | null | undefined;
    getChangeValueType(columnIndex: number, stage: SqliteValueStage): DbValueType | undefined;
    getColumnNames(tableName: string): string[];
    getColumnValueType(columnIndex: number, stage: SqliteValueStage): DbValueType | undefined;
    getDdlChanges(): string | undefined;
    getPrimaryKeyColumnNames(): string[];
    get hasRow(): boolean;
    isColumnValueNull(columnIndex: number, stage: SqliteValueStage): boolean | undefined;
    get isIndirect(): boolean;
    get op(): SqliteChangeOp;
    static openFile(args: {
        readonly fileName: string;
    } & SqliteChangesetReaderArgs): SqliteChangesetReader;
    static openGroup(args: {
        readonly changesetFiles: string[];
    } & SqliteChangesetReaderArgs): SqliteChangesetReader;
    static openInMemory(args: SqliteChangesetReaderArgs & {
        db: IModelDb;
    }): SqliteChangesetReader;
    static openLocalChanges(args: Omit<SqliteChangesetReaderArgs, "db"> & {
        db: IModelDb;
        includeInMemoryChanges?: true;
    }): SqliteChangesetReader;
    static openTxn(args: {
        txnId: Id64String;
    } & SqliteChangesetReaderArgs): SqliteChangesetReader;
    get primaryKeyValues(): SqliteValueArray;
    step(): boolean;
    get tableName(): string;
    writeToFile(args: {
        fileName: string;
        containsSchemaChanges: boolean;
        overwriteFile?: boolean;
    }): void;
}

// @beta
export interface SqliteChangesetReaderArgs {
    readonly db: AnyDb;
    readonly disableSchemaCheck?: true;
    readonly invert?: true;
}

// @public
export class SQLiteDb {
    // @internal (undocumented)
    readonly [_nativeDb]: IModelJsNative.SQLiteDb;
    abandonChanges(): void;
    closeDb(saveChanges?: boolean): void;
    // @beta
    get cloudContainer(): CloudSqlite.CloudContainer | undefined;
    // @internal (undocumented)
    static createBlobIO(): SQLiteDb.BlobIO;
    createDb(dbName: string): void;
    // @beta (undocumented)
    createDb(dbName: string, container?: CloudSqlite.CloudContainer, params?: SQLiteDb.CreateParams): void;
    protected createTable(args: {
        tableName: string;
        columns: string;
        constraints?: string;
        addTimestamp?: boolean;
    }): void;
    // @deprecated
    dispose(): void;
    executeSQL(sql: string): DbResult;
    getLastInsertRowId(): number;
    get isOpen(): boolean;
    get isReadonly(): boolean;
    openDb(dbName: string, openMode: OpenMode | SQLiteDb.OpenParams): void;
    // @beta (undocumented)
    openDb(dbName: string, openMode: OpenMode | SQLiteDb.OpenParams, container?: CloudSqlite.CloudContainer): void;
    // @internal
    prepareSqliteStatement(sql: string, logErrors?: boolean): SqliteStatement;
    readLastModTime(tableName: string, rowId: number): Date;
    saveChanges(): void;
    vacuum(args?: SQLiteDb.VacuumDbArgs): void;
    // @internal
    withLockedContainer<T>(args: CloudSqlite.LockAndOpenArgs, operation: () => Promise<T>): Promise<T>;
    withOpenDb<T>(args: SQLiteDb.WithOpenDbArgs, operation: () => T): T;
    withPreparedSqliteStatement<T>(sql: string, callback: (stmt: SqliteStatement) => T): T;
    withSavePoint(savePointName: string, operation: () => void): void;
    withSqliteStatement<T>(sql: string, callback: (stmt: SqliteStatement) => T): T;
}

// @public (undocumented)
export namespace SQLiteDb {
    // @internal
    export interface BlobIO {
        changeRow(row: number): void;
        close(): void;
        getNumBytes(): number;
        isValid(): boolean;
        open(
        db: IModelJsNative.AnyDb, args: {
            tableName: string;
            columnName: string;
            row: number;
            writeable?: boolean;
        }): void;
        read(args: {
            numBytes: number;
            offset: number;
            blob?: ArrayBuffer;
        }): Uint8Array;
        write(args: {
            numBytes: number;
            offset: number;
            blob: ArrayBuffer;
        }): void;
    }
    export type CreateParams = OpenOrCreateParams & PageSize;
    export enum DefaultTxnMode {
        Deferred = 1,
        Exclusive = 3,
        Immediate = 2,
        None = 0
    }
    export interface OpenOrCreateParams {
        defaultTxn?: 0 | 1 | 2 | 3;
        // (undocumented)
        immutable?: boolean;
        queryParam?: string;
        rawSQLite?: boolean;
        skipFileCheck?: boolean;
    }
    export interface OpenParams extends OpenOrCreateParams {
        openMode: OpenMode;
    }
    export interface PageSize {
        pageSize?: number;
    }
    export interface RequiredVersionRanges {
        readonly readVersion: VersionRange;
        readonly writeVersion: VersionRange;
    }
    export interface VacuumDbArgs extends PageSize {
        into?: LocalFileName;
    }
    export type VersionRange = string;
    export interface WithOpenDbArgs {
        // @internal (undocumented)
        container?: CloudSqlite.CloudContainer;
        dbName: string;
        openMode?: OpenMode | SQLiteDb.OpenParams;
    }
}

// @public
export class SqliteStatement implements IterableIterator<any>, Disposable {
    [Symbol.dispose](): void;
    [Symbol.iterator](): IterableIterator<any>;
    constructor(_sql: string);
    bindBlob(parameter: BindParameter, blob: Uint8Array): void;
    bindBoolean(parameter: BindParameter, val: boolean): void;
    bindDouble(parameter: BindParameter, val: number): void;
    bindGuid(parameter: BindParameter, guid: GuidString): void;
    bindId(parameter: BindParameter, id: Id64String): void;
    bindInteger(parameter: BindParameter, val: number): void;
    bindNull(parameter: BindParameter): void;
    // @internal
    bindProps<T>(colIndex: number, val: T): void;
    bindString(parameter: BindParameter, val: string): void;
    bindValue(parameter: BindParameter, value: any): void;
    bindValues(values: any[] | object): void;
    clearBindings(): void;
    // @deprecated (undocumented)
    dispose(): void;
    getColumnBytes(colIndex: number): number;
    getColumnCount(): number;
    // @internal
    getProps<T>(colIndex: number): T;
    // @internal
    getPropsMaybe<T>(colIndex: number): T | undefined;
    getRow(): any;
    getValue(columnIx: number): SqliteValue;
    getValueBlob(colIndex: number): Uint8Array;
    getValueBlobMaybe(colIndex: number): Uint8Array | undefined;
    getValueBoolean(colIndex: number): boolean;
    // @beta
    getValueDate(colIndex: number): Date;
    getValueDouble(colIndex: number): number;
    getValueDoubleMaybe(colIndex: number): number | undefined;
    getValueGuid(colIndex: number): GuidString;
    getValueId(colIndex: number): Id64String;
    getValueInteger(colIndex: number): number;
    getValueIntegerMaybe(colIndex: number): number | undefined;
    getValueString(colIndex: number): string;
    getValueStringMaybe(colIndex: number): string | undefined;
    get isPrepared(): boolean;
    get isReadonly(): boolean;
    isValueNull(colIndex: number): boolean;
    maybeBindBlob(parameter: BindParameter, val?: Uint8Array): void;
    maybeBindBoolean(parameter: BindParameter, val?: boolean): void;
    maybeBindDouble(parameter: BindParameter, val?: number): void;
    maybeBindInteger(parameter: BindParameter, val?: number): void;
    // @internal
    maybeBindProps<T>(colIndex: number, val?: T): void;
    maybeBindString(parameter: BindParameter, val?: string): void;
    next(): IteratorResult<any>;
    nextRow(): boolean;
    prepare(db: IModelJsNative.AnyDb, logErrors?: boolean): void;
    reset(): void;
    // (undocumented)
    get sql(): string;
    step(): DbResult;
    // (undocumented)
    stepForWrite(): void;
    // (undocumented)
    get stmt(): IModelJsNative.SqliteStatement;
    // (undocumented)
    throwSqlError(rc: DbResult): void;
}

// @public (undocumented)
export namespace SqliteStatement {
    // (undocumented)
    export class DbError extends BentleyError {
        // @internal
        constructor(errorId: ErrorId, errNum: number, message: string);
        readonly errorId: ErrorId;
    }
    // (undocumented)
    export type ErrorId = "DuplicateValue" | "SqlLogicError" | "ValueIsInUse";
}

// @public
export class SqliteValue {
    constructor(stmt: IModelJsNative.SqliteStatement, colIndex: number);
    get columnName(): string;
    getBlob(): Uint8Array;
    getDouble(): number;
    getGuid(): GuidString;
    getId(): Id64String;
    getInteger(): number;
    getString(): string;
    get isNull(): boolean;
    get type(): SqliteValueType;
    get value(): any;
}

// @beta
export type SqliteValueStage = "Old" | "New";

// @public
export enum SqliteValueType {
    // (undocumented)
    Blob = 4,
    // (undocumented)
    Double = 2,
    // (undocumented)
    Integer = 1,
    // (undocumented)
    Null = 5,
    // (undocumented)
    String = 3
}

// @public
export class StandaloneDb extends BriefcaseDb {
    // @beta
    static convertToStandalone(iModelFileName: LocalFileName): void;
    // @beta
    createClassViews(): void;
    static createEmpty(filePath: LocalFileName, args: CreateEmptyStandaloneIModelProps): StandaloneDb;
    // (undocumented)
    static findByKey(key: string): StandaloneDb;
    // (undocumented)
    get isStandalone(): boolean;
    static openFile(filePath: LocalFileName, openMode?: OpenMode, options?: SnapshotDbOpenArgs): StandaloneDb;
    // (undocumented)
    static tryFindByKey(key: string): StandaloneDb | undefined;
    static upgradeStandaloneSchemas(filePath: LocalFileName): void;
    // (undocumented)
    protected get useLockServer(): boolean;
}

// @internal
export class StatementCache<Stmt extends Statement> {
    constructor(maxCount?: number);
    // (undocumented)
    addOrDispose(stmt: Stmt): void;
    // (undocumented)
    clear(): void;
    // (undocumented)
    findAndRemove(sql: string): Stmt | undefined;
    // (undocumented)
    get size(): number;
}

// @internal
export interface StringParam {
    // (undocumented)
    guid?: GuidString;
    // (undocumented)
    id?: Id64String;
}

// @public @preview
export class SubCategory extends DefinitionElement {
    protected constructor(props: SubCategoryProps, iModel: IModelDb);
    appearance: SubCategoryAppearance;
    // (undocumented)
    static get className(): string;
    static create(iModelDb: IModelDb, parentCategoryId: Id64String, name: string, appearance: SubCategoryAppearance.Props | SubCategoryAppearance): SubCategory;
    static createCode(iModel: IModelDb, parentCategoryId: CodeScopeProps, codeValue: string): Code;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    description?: string;
    // @beta
    static deserialize(props: DeserializeEntityArgs): SubCategoryProps;
    getCategoryId(): Id64String;
    getSubCategoryId(): Id64String;
    getSubCategoryName(): string;
    static insert(iModelDb: IModelDb, parentCategoryId: Id64String, name: string, appearance: SubCategoryAppearance.Props | SubCategoryAppearance): Id64String;
    get isDefaultSubCategory(): boolean;
    // @beta
    static serialize(props: SubCategoryProps, iModel: IModelDb): ECSqlRow;
    // (undocumented)
    toJSON(): SubCategoryProps;
}

// @public @preview
export class Subject extends InformationReferenceElement {
    protected constructor(props: SubjectProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static create(iModelDb: IModelDb, parentSubjectId: Id64String, name: string, description?: string): Subject;
    static createCode(iModelDb: IModelDb, parentSubjectId: CodeScopeProps, codeValue: string): Code;
    // (undocumented)
    description?: string;
    static insert(iModelDb: IModelDb, parentSubjectId: Id64String, name: string, description?: string): Id64String;
    // (undocumented)
    toJSON(): SubjectProps;
}

// @public
export class SubjectOwnsPartitionElements extends ElementOwnsChildElements {
    constructor(parentId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @beta
export class SubjectOwnsProjectInformationRecord extends ElementOwnsChildElements {
    constructor(parentId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @public
export class SubjectOwnsSubjects extends ElementOwnsChildElements {
    constructor(parentId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @beta
export class SynchronizationConfigLink extends UrlLink {
    protected constructor(props: SynchronizationConfigLinkProps, iModel: IModelDb);
    // @internal (undocumented)
    static get className(): string;
    lastSuccessfulRun?: string;
    // (undocumented)
    toJSON(): SynchronizationConfigLinkProps;
}

// @beta
export class SynchronizationConfigProcessesSources extends ElementRefersToElements {
    // (undocumented)
    static get className(): string;
}

// @beta
export class SynchronizationConfigSpecifiesRootSources extends SynchronizationConfigProcessesSources {
    // (undocumented)
    static get className(): string;
}

// @beta
export class TemplateRecipe2d extends RecipeDefinitionElement {
    protected constructor(props: ElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static create(iModelDb: IModelDb, definitionModelId: Id64String, name: string, isPrivate?: boolean): TemplateRecipe2d;
    static createCode(iModelDb: IModelDb, definitionModelId: CodeScopeProps, codeValue: string): Code;
    static insert(iModelDb: IModelDb, definitionModelId: Id64String, name: string, isPrivate?: boolean): Id64String;
}

// @beta
export class TemplateRecipe3d extends RecipeDefinitionElement {
    protected constructor(props: ElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    static create(iModelDb: IModelDb, definitionModelId: Id64String, name: string, isPrivate?: boolean): TemplateRecipe3d;
    static createCode(iModelDb: IModelDb, definitionModelId: CodeScopeProps, codeValue: string): Code;
    static insert(iModelDb: IModelDb, definitionModelId: Id64String, name: string, isPrivate?: boolean): Id64String;
}

// @internal
export class TemplateViewDefinition2d extends ViewDefinition2d {
    // (undocumented)
    static get className(): string;
}

// @internal
export class TemplateViewDefinition3d extends ViewDefinition3d {
    // (undocumented)
    static get className(): string;
}

// @internal
export const TEXT_ANNOTATION_JSON_VERSION = "1.0.0";

// @internal
export const TEXT_STYLE_SETTINGS_JSON_VERSION = "1.0.2";

// @public @preview
export class TextAnnotation2d extends AnnotationElement2d {
    protected constructor(props: TextAnnotation2dProps, iModel: IModelDb);
    // @internal (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    // @beta
    static create(iModelDb: IModelDb, arg: TextAnnotation2dCreateArgs): TextAnnotation2d;
    // @internal
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // @beta
    defaultTextStyle?: TextAnnotationUsesTextStyleByDefault;
    // @beta
    static deserialize(props: DeserializeEntityArgs): TextAnnotation2dProps;
    static fromJSON(props: TextAnnotation2dProps, iModel: IModelDb): TextAnnotation2d;
    getAnnotation(): TextAnnotation | undefined;
    // @internal (undocumented)
    getTextBlocks(): Iterable<TextBlockAndId>;
    // @internal (undocumented)
    protected static onCloned(context: IModelElementCloneContext, srcProps: TextAnnotation2dProps, dstProps: TextAnnotation2dProps): Promise<void>;
    // @beta
    protected static onInsert(arg: OnElementPropsArg): void;
    // @internal (undocumented)
    static onInserted(arg: OnElementIdArg): void;
    // @beta
    protected static onUpdate(arg: OnElementPropsArg): void;
    // @internal (undocumented)
    static onUpdated(arg: OnElementIdArg): void;
    // @beta
    static serialize(props: TextAnnotation2dProps, iModel: IModelDb): ECSqlRow;
    setAnnotation(annotation: TextAnnotation): void;
    toJSON(): TextAnnotation2dProps;
    // @internal (undocumented)
    updateTextBlocks(textBlocks: TextBlockAndId[]): void;
    // @beta
    protected static validateVersionAndUpdateGeometry(arg: OnElementPropsArg): void;
}

// @beta
export interface TextAnnotation2dCreateArgs {
    category: Id64String;
    code?: CodeProps;
    defaultTextStyleId?: Id64String;
    model: Id64String;
    placement: Placement2dProps;
    textAnnotationProps?: TextAnnotationProps;
}

// @public @preview
export class TextAnnotation3d extends GraphicalElement3d {
    protected constructor(props: TextAnnotation3dProps, iModel: IModelDb);
    // @internal (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    // @beta
    static create(iModelDb: IModelDb, arg: TextAnnotation3dCreateArgs): TextAnnotation3d;
    // @internal
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // @beta
    defaultTextStyle?: TextAnnotationUsesTextStyleByDefault;
    // @beta
    static deserialize(props: DeserializeEntityArgs): TextAnnotation3dProps;
    static fromJSON(props: TextAnnotation3dProps, iModel: IModelDb): TextAnnotation3d;
    getAnnotation(): TextAnnotation | undefined;
    // @internal (undocumented)
    getTextBlocks(): Iterable<TextBlockAndId>;
    // @internal (undocumented)
    protected static onCloned(context: IModelElementCloneContext, srcProps: TextAnnotation3dProps, dstProps: TextAnnotation3dProps): Promise<void>;
    // @beta
    protected static onInsert(arg: OnElementPropsArg): void;
    // @internal (undocumented)
    static onInserted(arg: OnElementIdArg): void;
    // @beta
    protected static onUpdate(arg: OnElementPropsArg): void;
    // @internal (undocumented)
    static onUpdated(arg: OnElementIdArg): void;
    // @beta
    static serialize(props: TextAnnotation3dProps, iModel: IModelDb): ECSqlRow;
    setAnnotation(annotation: TextAnnotation): void;
    toJSON(): TextAnnotation3dProps;
    // @internal (undocumented)
    updateTextBlocks(textBlocks: TextBlockAndId[]): void;
    // @beta
    protected static validateVersionAndUpdateGeometry(arg: OnElementPropsArg): void;
}

// @beta
export interface TextAnnotation3dCreateArgs {
    category: Id64String;
    code?: CodeProps;
    defaultTextStyleId?: Id64String;
    model: Id64String;
    placement: Placement3dProps;
    textAnnotationProps?: TextAnnotationProps;
}

// @beta
export class TextAnnotationUsesTextStyleByDefault extends RelatedElement {
    constructor(annotationTextStyleId: Id64String, relClassName?: string);
    // (undocumented)
    static classFullName: string;
}

// @beta
export interface TextBlockAndId {
    readonly id: unknown;
    readonly textBlock: TextBlock;
}

// @beta
export class TextBlockLayout {
    constructor(source: TextBlock, context: LayoutContext);
    // (undocumented)
    lines: LineLayout[];
    range: Range2d;
    // (undocumented)
    source: TextBlock;
    stringify(): string;
    textRange: Range2d;
    // (undocumented)
    toResult(): TextBlockLayoutResult;
}

// @internal (undocumented)
export interface TextLayoutRanges {
    // (undocumented)
    justification: Range2d;
    // (undocumented)
    layout: Range2d;
}

// @beta
export interface TextStyleCreateArgs {
    definitionModelId: Id64String;
    description?: string;
    name: string;
    settings?: TextStyleSettingsProps;
}

// @beta
export class TextStyleResolver {
    constructor(args: TextStyleResolverArgs);
    readonly blockSettings: TextStyleSettings;
    resolveIndentation(styleOverrides: TextStyleSettingsProps, depth: number): number;
    // (undocumented)
    resolveMarkerText(overrides: TextStyleSettingsProps, index: number): string;
    resolveSettings(overrides: TextStyleSettingsProps, isLeader?: boolean): TextStyleSettings;
}

// @beta
export interface TextStyleResolverArgs {
    // @internal
    findTextStyle?: FindTextStyle;
    iModel: IModelDb;
    textBlock: TextBlock;
    textStyleId: Id64String;
}

// @public @preview
export class Texture extends DefinitionElement {
    // @beta
    protected constructor(props: TextureCreateProps, iModel: IModelDb);
    // @internal (undocumented)
    static get className(): string;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, name: string): Code;
    static createTexture(iModelDb: IModelDb, definitionModelId: Id64String, name: string, format: ImageSourceFormat, data: Uint8Array | Base64EncodedString, description?: string): Texture;
    // (undocumented)
    data: Uint8Array;
    // (undocumented)
    description?: string;
    // (undocumented)
    format: ImageSourceFormat;
    static insertTexture(iModelDb: IModelDb, definitionModelId: Id64String, name: string, format: ImageSourceFormat, data: Uint8Array | Base64EncodedString, description?: string): Id64String;
    // (undocumented)
    toJSON(): TextureProps;
}

// @beta
export interface TextureCreateProps extends Omit<TextureProps, "data"> {
    // (undocumented)
    data: Base64EncodedString | Uint8Array;
}

// @internal
export function throttleProgressCallback(func: ProgressFunction, checkAbort: () => ProgressStatus, progressInterval?: number): ProgressFunction;

// @beta
export interface TileId {
    // (undocumented)
    contentId: string;
    // (undocumented)
    guid: string;
    // (undocumented)
    treeId: string;
}

// @beta
export class TileStorage {
    constructor(storage: ServerStorage);
    downloadTile(iModelId: string, changesetId: string, treeId: string, contentId: string, guid?: string): Promise<Uint8Array>;
    getCachedTiles(iModelId: string): Promise<TileId[]>;
    getCachedTilesGenerator(iModelId: string): AsyncGenerator<TileId>;
    getDownloadConfig(iModelId: string, expiresInSeconds?: number): Promise<TransferConfig>;
    initialize(iModelId: string): Promise<void>;
    isTileCached(iModelId: string, changesetId: string, treeId: string, contentId: string, guid?: string): Promise<boolean>;
    readonly storage: ServerStorage;
    uploadTile(iModelId: string, changesetId: string, treeId: string, contentId: string, content: Uint8Array, guid?: string, metadata?: Metadata): Promise<void>;
}

// @public
export class TitleText extends DetailingSymbol {
    constructor(props: GeometricElement2dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public
export interface ToChangesetArgs extends TokenArg {
    toIndex?: ChangesetIndex;
}

// @public
export interface TokenArg {
    readonly accessToken?: AccessToken;
}

// @public @preview
export interface TxnChangedEntities {
    readonly deletes: EntityIdAndClassIdIterable;
    readonly inserts: EntityIdAndClassIdIterable;
    readonly updates: EntityIdAndClassIdIterable;
}

// @public @preview
export type TxnIdString = string;

// @public @preview
export class TxnManager {
    // @internal
    constructor(_iModel: BriefcaseDb | StandaloneDb);
    // @internal
    appCustomConflictHandler?: (args: DbRebaseChangesetConflictArgs) => DbConflictResolution | undefined;
    beginMultiTxnOperation(): DbResult;
    cancelTo(txnId: TxnIdString): IModelStatus;
    deleteAllTxns(): void;
    endMultiTxnOperation(): DbResult;
    getChangeTrackingMemoryUsed(): number;
    // @alpha
    getCurrentSessionId(): number;
    getCurrentTxnId(): TxnIdString;
    // @alpha
    getLastSavedTxnProps(): TxnProps | undefined;
    // @alpha
    getMode(): TxnMode;
    getMultiTxnOperationDepth(): number;
    getRedoString(): string;
    getTxnDescription(txnId: TxnIdString): string;
    // @alpha
    getTxnProps(id: TxnIdString): TxnProps | undefined;
    getUndoString(): string;
    get hasFatalError(): boolean;
    get hasLocalChanges(): boolean;
    // @alpha
    get hasPendingSchemaChanges(): boolean;
    get hasPendingTxns(): boolean;
    get hasUnsavedChanges(): boolean;
    // @internal (undocumented)
    get isDisposed(): boolean;
    get isIndirectChanges(): boolean;
    get isRedoPossible(): boolean;
    isTxnIdValid(txnId: TxnIdString): boolean;
    get isUndoPossible(): boolean;
    readonly onAfterUndoRedo: BeEvent<(isUndo: boolean) => void>;
    // @internal (undocumented)
    protected _onAfterUndoRedo(isUndo: boolean): void;
    // @internal (undocumented)
    protected _onAllInputsHandled(elClassName: string, elId: Id64String): void;
    // @internal (undocumented)
    protected _onBeforeOutputsHandled(elClassName: string, elId: Id64String): void;
    readonly onBeforeUndoRedo: BeEvent<(isUndo: boolean) => void>;
    // @internal (undocumented)
    protected _onBeforeUndoRedo(isUndo: boolean): void;
    // @internal (undocumented)
    protected _onBeginValidate(): void;
    readonly onChangesApplied: BeEvent<() => void>;
    // @internal (undocumented)
    protected _onChangesApplied(): void;
    readonly onChangesPulled: BeEvent<(parentChangeset: ChangesetIndexAndId) => void>;
    // @internal (undocumented)
    _onChangesPulled(changeset: ChangesetIndexAndId): void;
    readonly onChangesPushed: BeEvent<(parentChangeset: ChangesetIndexAndId) => void>;
    // @internal (undocumented)
    _onChangesPushed(changeset: ChangesetIndexAndId): void;
    readonly onCommit: BeEvent<() => void>;
    // @internal (undocumented)
    protected _onCommit(): void;
    readonly onCommitted: BeEvent<() => void>;
    // @internal (undocumented)
    protected _onCommitted(): void;
    // @internal (undocumented)
    protected _onDeletedDependency(props: RelationshipProps): void;
    readonly onElementsChanged: BeEvent<(changes: TxnChangedEntities) => void>;
    // @internal
    protected _onEndValidate(): void;
    // @internal (undocumented)
    readonly onEndValidation: BeEvent<() => void>;
    // (undocumented)
    readonly onGeometryChanged: BeEvent<(models: ModelGeometryChangesProps[]) => void>;
    // @internal (undocumented)
    protected _onGeometryChanged(modelProps: ModelGeometryChangesProps[]): void;
    // @internal (undocumented)
    protected _onGeometryGuidsChanged(changes: ModelIdAndGeometryGuid[]): void;
    readonly onModelGeometryChanged: BeEvent<(changes: ReadonlyArray<ModelIdAndGeometryGuid>) => void>;
    readonly onModelsChanged: BeEvent<(changes: TxnChangedEntities) => void>;
    readonly onReplayedExternalTxns: BeEvent<() => void>;
    // @internal (undocumented)
    protected _onReplayedExternalTxns(): void;
    readonly onReplayExternalTxns: BeEvent<() => void>;
    // @internal (undocumented)
    protected _onReplayExternalTxns(): void;
    // @internal (undocumented)
    protected _onRootChanged(props: RelationshipProps): void;
    queryFirstTxnId(): TxnIdString;
    // @beta
    queryLocalChanges(args?: QueryLocalChangesArgs): Iterable<ChangeInstanceKey>;
    queryNextTxnId(txnId: TxnIdString): TxnIdString;
    queryPreviousTxnId(txnId: TxnIdString): TxnIdString;
    // @alpha
    queryTxns(): Generator<TxnProps>;
    // @internal (undocumented)
    readonly rebaser: RebaseManager;
    reinstateTxn(): IModelStatus;
    reportError(error: ValidationError): void;
    restartSession(): void;
    reverseAll(): IModelStatus;
    reverseSingleTxn(): IModelStatus;
    reverseTo(txnId: TxnIdString): IModelStatus;
    reverseTxns(numOperations: number): IModelStatus;
    // @internal
    touchWatchFile(): void;
    readonly validationErrors: ValidationError[];
    // @alpha
    withIndirectTxnMode(callback: () => void): void;
    // @alpha
    withIndirectTxnModeAsync(callback: () => Promise<void>): Promise<void>;
}

// @alpha
export type TxnMode = "direct" | "indirect";

// @public @preview
export abstract class TypeDefinitionElement extends DefinitionElement {
    protected constructor(props: TypeDefinitionElementProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    // (undocumented)
    recipe?: RelatedElement;
}

// @public
export interface UpdateModelOptions extends ModelProps {
    geometryChanged?: boolean;
    updateLastMod?: boolean;
}

// @beta
export function upgradeCustomAttributesToEC3(xmlSchemas: string[], schemaContext?: ECSchemaXmlContext): string[];

// @public @preview
export class UrlLink extends LinkElement {
    protected constructor(props: UrlLinkProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // (undocumented)
    description?: string;
    // @beta
    static deserialize(props: DeserializeEntityArgs): UrlLinkProps;
    // @beta
    static serialize(props: UrlLinkProps, iModel: IModelDb): ECSqlRow;
    // (undocumented)
    toJSON(): UrlLinkProps;
    // (undocumented)
    url?: string;
}

// @public
export interface V2CheckpointAccessProps {
    readonly accountName: string;
    readonly containerId: string;
    readonly dbName: string;
    readonly sasToken: AccessToken;
    readonly storageType: string;
}

// @internal
export class V2CheckpointManager {
    static [_mockCheckpoint]?: MockCheckpoint;
    // (undocumented)
    static attach(checkpoint: CheckpointProps): Promise<{
        dbName: string;
        container: CloudSqlite.CloudContainer | undefined;
    }>;
    // (undocumented)
    static cleanup(): void;
    // (undocumented)
    static readonly cloudCacheName = "Checkpoints";
    static downloadCheckpoint(request: DownloadRequest): Promise<ChangesetId>;
    // (undocumented)
    static getFolder(): LocalDirName;
}

// @public @preview
export interface ValidationError {
    errorType: string;
    fatal: boolean;
    message?: string;
}

// @beta
export abstract class VersionedSqliteDb extends SQLiteDb {
    protected abstract createDDL(args: any): void;
    static createNewDb(fileName: LocalFileName, setupArgs?: any): void;
    getRequiredVersions(): SQLiteDb.RequiredVersionRanges;
    abstract myVersion: string;
    openDb(dbName: string, openMode: OpenMode | SQLiteDb.OpenParams, container?: CloudSqlite.CloudContainer): void;
    setRequiredVersions(versions: SQLiteDb.RequiredVersionRanges): void;
    // (undocumented)
    upgradeSchema(arg: {
        dbName: string;
        lockContainer?: {
            container: CloudSqlite.CloudContainer;
            user: string;
        };
        upgradeFn: () => void;
    }): Promise<void | (() => void)>;
    protected verifyVersions(): void;
    // (undocumented)
    protected static _versionProps: {
        readonly namespace: "SQLiteDb";
        readonly name: "versions";
    };
}

// @public @preview
export class ViewAttachment extends GraphicalElement2d {
    constructor(props: ViewAttachmentProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    // (undocumented)
    view: RelatedElement;
}

// @public
export class ViewAttachmentLabel extends DetailingSymbol {
    constructor(props: ViewAttachmentLabelProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public @preview
export abstract class ViewDefinition extends DefinitionElement {
    protected constructor(props: ViewDefinitionProps, iModel: IModelDb);
    categorySelectorId: Id64String;
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    static createCode(iModel: IModelDb, scopeModelId: CodeScopeProps, codeValue: string): Code;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // @beta
    static deserialize(props: DeserializeEntityArgs): ViewDefinitionProps;
    abstract get details(): ViewDetails;
    displayStyleId: Id64String;
    getAuxiliaryCoordinateSystemId(): Id64String;
    isDrawingView(): this is DrawingViewDefinition;
    isSpatialView(): this is SpatialViewDefinition;
    isView2d(): this is ViewDefinition2d;
    isView3d(): this is ViewDefinition3d;
    loadCategorySelector(): CategorySelector;
    loadDisplayStyle(): DisplayStyle;
    // @beta (undocumented)
    protected static onCloned(context: IModelElementCloneContext, sourceElementProps: ViewDefinitionProps, targetElementProps: ViewDefinitionProps): Promise<void>;
    // @beta (undocumented)
    static readonly requiredReferenceKeys: ReadonlyArray<string>;
    // @alpha (undocumented)
    static readonly requiredReferenceKeyTypeMap: Record<string, ConcreteEntityTypes>;
    // @beta
    static serialize(props: ViewDefinitionProps, _iModel: IModelDb): ECSqlRow;
    setAuxiliaryCoordinateSystemId(acsId: Id64String): void;
    // (undocumented)
    toJSON(): ViewDefinitionProps;
}

// @public @preview
export class ViewDefinition2d extends ViewDefinition {
    protected constructor(props: ViewDefinition2dProps, iModel: IModelDb);
    angle: Angle;
    baseModelId: Id64String;
    // (undocumented)
    static get className(): string;
    // (undocumented)
    protected collectReferenceIds(referenceIds: EntityReferenceSet): void;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    delta: Point2d;
    // @beta
    static deserialize(props: DeserializeEntityArgs): ViewDefinition2dProps;
    get details(): ViewDetails;
    loadDisplayStyle2d(): DisplayStyle2d;
    origin: Point2d;
    // @beta
    static serialize(props: ViewDefinition2dProps, _iModel: IModelDb): ECSqlRow;
    // (undocumented)
    toJSON(): ViewDefinition2dProps;
}

// @public @preview
export abstract class ViewDefinition3d extends ViewDefinition {
    protected constructor(props: ViewDefinition3dProps, iModel: IModelDb);
    angles: YawPitchRollAngles;
    camera: Camera;
    cameraOn: boolean;
    // (undocumented)
    static get className(): string;
    // @beta
    protected static readonly _customHandledProps: CustomHandledProperty[];
    // @beta
    static deserialize(props: DeserializeEntityArgs): ViewDefinition3dProps;
    get details(): ViewDetails3d;
    extents: Vector3d;
    loadDisplayStyle3d(): DisplayStyle3d;
    origin: Point3d;
    // @beta
    static serialize(props: ViewDefinition3dProps, _iModel: IModelDb): ECSqlRow;
    // (undocumented)
    toJSON(): ViewDefinition3dProps;
}

// @beta
export namespace ViewStore {
    const // (undocumented)
    tableName: {
        readonly categorySelectors: "categorySelectors";
        readonly displayStyles: "displayStyles";
        readonly viewGroups: "viewGroups";
        readonly guids: "guids";
        readonly modelSelectors: "modelSelectors";
        readonly taggedViews: "taggedViews";
        readonly tags: "tags";
        readonly thumbnails: "thumbnails";
        readonly timelines: "timelines";
        readonly searches: "searches";
        readonly views: "views";
    };
    export class CloudAccess extends CloudSqlite.DbAccess<ViewDb, ReadMethods, ViewStoreRpc.Writer> {
        constructor(props: ViewStoreCtorProps);
        static createNewContainer(args: CreateNewContainerProps): Promise<CloudSqlite.ContainerProps>;
        // @internal
        static initializeDb(props: CloudSqlite.ContainerProps): Promise<void>;
    }
    // (undocumented)
    export interface CreateNewContainerProps {
        // (undocumented)
        metadata: Omit<BlobContainer.Metadata, "containerType">;
        // (undocumented)
        scope: BlobContainer.Scope;
    }
    // (undocumented)
    export type DisplayStyleRow = TableRow;
    export interface ReadMethods extends ViewStoreRpc.Reader {
        // (undocumented)
        getCategorySelectorSync(args: ViewStoreRpc.NameOrId & ViewStoreRpc.QueryBindings): CategorySelectorProps;
        // (undocumented)
        getDisplayStyleSync(args: ViewStoreRpc.NameOrId & {
            opts?: DisplayStyleLoadProps;
        }): DisplayStyleProps;
        // (undocumented)
        getModelSelectorSync(args: ViewStoreRpc.NameOrId & ViewStoreRpc.QueryBindings): ModelSelectorProps;
        // (undocumented)
        getThumbnailSync(args: {
            viewId: RowString;
        }): ThumbnailProps | undefined;
        // (undocumented)
        getViewByNameSync(arg: {
            name: ViewStoreRpc.ViewName;
            groupId?: RowId;
        }): ViewStoreRpc.ViewInfo | undefined;
        // (undocumented)
        getViewDefinitionSync(args: {
            viewId: RowString;
        }): ViewDefinitionProps;
        // (undocumented)
        queryViewsSync(queryParams: ViewStoreRpc.QueryParams): ViewStoreRpc.ViewInfo[];
    }
    export type RowId = number;
    // (undocumented)
    export type RowIdOrString = RowId | RowString;
    export type RowString = string;
    // (undocumented)
    export type SearchRow = TableRow;
    // (undocumented)
    export type SelectorRow = TableRow;
    export interface TableRow {
        // (undocumented)
        json: string;
        // (undocumented)
        name?: string;
        // (undocumented)
        owner?: string;
    }
    // (undocumented)
    export type TagRow = TableRow;
    export type ThumbnailData = Uint8Array;
    const fromRowId: (rowId: RowId) => RowString;
    export interface ThumbnailRow {
        // (undocumented)
        data: ThumbnailData;
        // (undocumented)
        format: ThumbnailFormatProps;
        // (undocumented)
        owner?: string;
        // (undocumented)
        viewId: RowId;
    }
    const // @internal (undocumented)
    toRowId: (id: RowIdOrString) => RowId;
    const // (undocumented)
    defaultViewGroupId = 1;
    // (undocumented)
    export type TimelineRow = TableRow;
    // (undocumented)
    export class ViewDb extends VersionedSqliteDb implements ViewStoreRpc.Writer, ReadMethods {
        constructor(arg?: ViewDbCtorArgs);
        // (undocumented)
        addCategorySelector(args: {
            name?: string;
            selector: ViewStoreRpc.SelectorProps;
            owner?: string;
        }): Promise<RowString>;
        // @internal
        addCategorySelectorRow(args: SelectorRow): RowId;
        // (undocumented)
        addDisplayStyle(args: {
            name?: string;
            className: string;
            settings: DisplayStyleSettingsProps;
            owner?: string;
        }): Promise<RowString>;
        // @internal
        addDisplayStyleRow(args: DisplayStyleRow): RowId;
        // @internal (undocumented)
        addGuid(guid: GuidString): RowId;
        // (undocumented)
        addModelSelector(args: {
            name?: string;
            selector: ViewStoreRpc.SelectorProps;
            owner?: string;
        }): Promise<RowString>;
        // @internal
        addModelSelectorRow(args: SelectorRow): RowId;
        // (undocumented)
        addOrReplaceThumbnail(args: {
            viewId: RowIdOrString;
            readonly thumbnail: ThumbnailProps;
            owner?: string;
        }): Promise<void>;
        // @internal
        addOrReplaceThumbnailRow(args: ThumbnailRow): RowId;
        // @internal
        addSearch(args: SearchRow): Promise<RowId>;
        // @internal
        addTag(args: TagRow): RowId;
        // (undocumented)
        addTagsToView(args: {
            viewId: RowIdOrString;
            tags: string[];
            owner?: string;
        }): Promise<void>;
        // @internal (undocumented)
        addTagToView(args: {
            viewId: RowId;
            tagId: RowId;
        }): void;
        // (undocumented)
        addTimeline(args: {
            name?: string;
            timeline: RenderSchedule.ScriptProps;
            owner?: string;
        }): Promise<RowString>;
        // @internal
        addTimelineRow(args: TimelineRow): RowId;
        // (undocumented)
        addView(args: ViewStoreRpc.AddViewArgs): Promise<ViewStoreRpc.IdString>;
        // (undocumented)
        addViewGroup(args: {
            name: string;
            parentId?: RowString;
            owner?: string;
        }): Promise<RowString>;
        // @internal (undocumented)
        addViewGroupRow(args: Optional<ViewGroupRow, "parentId">): RowId;
        // @internal (undocumented)
        addViewRow(args: ViewRow): RowId;
        // (undocumented)
        changeDefaultViewId(args: {
            defaultView: RowIdOrString;
            group?: ViewStoreRpc.ViewGroupSpec;
        }): Promise<void>;
        protected createDDL(): void;
        // (undocumented)
        deleteCategorySelector(args: {
            id: RowIdOrString;
        }): Promise<void>;
        // (undocumented)
        deleteCategorySelectorSync(id: RowIdOrString): void;
        // (undocumented)
        deleteDisplayStyle(args: {
            id: RowIdOrString;
        }): Promise<void>;
        // (undocumented)
        deleteDisplayStyleSync(id: RowIdOrString): void;
        // (undocumented)
        deleteModelSelector(args: {
            id: RowIdOrString;
        }): Promise<void>;
        // (undocumented)
        deleteModelSelectorSync(id: RowIdOrString): void;
        // (undocumented)
        deleteSearch(id: RowId): void;
        // (undocumented)
        deleteTag(arg: {
            name: ViewStoreRpc.TagName;
        }): Promise<void>;
        // (undocumented)
        deleteTagSync(arg: {
            name: ViewStoreRpc.TagName;
        }): void;
        // (undocumented)
        deleteThumbnail(arg: {
            viewId: RowString;
        }): Promise<void>;
        // (undocumented)
        deleteThumbnailSync(id: RowString): void;
        // (undocumented)
        deleteTimeline(args: {
            id: RowIdOrString;
        }): Promise<void>;
        // (undocumented)
        deleteTimelineSync(id: RowIdOrString): void;
        // (undocumented)
        deleteView(arg: {
            viewId: RowIdOrString;
        }): Promise<void>;
        // (undocumented)
        deleteViewGroup(args: {
            name: ViewStoreRpc.ViewGroupSpec;
        }): Promise<void>;
        // @internal (undocumented)
        deleteViewRow(id: RowIdOrString): void;
        // @internal (undocumented)
        findCategorySelectorByName(name: string): RowId;
        // @internal (undocumented)
        findDisplayStyleByName(name: string): RowId;
        // @internal (undocumented)
        findModelSelectorByName(name: string): RowId;
        // @internal (undocumented)
        findSearchByName(name: string): RowId;
        // @internal (undocumented)
        findTagByName(name: string): RowId;
        // @internal (undocumented)
        findTagIdsForView(viewId: RowId): RowId[];
        // @internal (undocumented)
        findTimelineByName(name: string): RowId;
        findViewGroup(groupName: ViewStoreRpc.ViewGroupSpec): RowId;
        // @internal
        findViewIdByName(arg: {
            name: string;
            groupId?: RowIdOrString;
        }): RowId;
        // (undocumented)
        findViewsByOwner(args: {
            owner: string;
        }): Promise<ViewStoreRpc.ViewInfo[]>;
        // @internal (undocumented)
        findViewsForTag(tagId: RowId): RowId[];
        // (undocumented)
        getCategorySelector(args: ViewStoreRpc.NameOrId & ViewStoreRpc.QueryBindings): Promise<CategorySelectorProps>;
        // @internal
        getCategorySelectorRow(id: RowId): SelectorRow | undefined;
        // @internal (undocumented)
        getCategorySelectorSync(args: ViewStoreRpc.NameOrId & ViewStoreRpc.QueryBindings): CategorySelectorProps;
        // (undocumented)
        getDisplayStyle(args: ViewStoreRpc.NameOrId & {
            opts?: DisplayStyleLoadProps;
        }): Promise<DisplayStyleProps>;
        // @internal
        getDisplayStyleRow(id: RowId): DisplayStyleRow | undefined;
        // (undocumented)
        getDisplayStyleSync(args: ViewStoreRpc.NameOrId & {
            opts?: DisplayStyleLoadProps;
        }): DisplayStyleProps;
        // @internal (undocumented)
        getGuid(rowid: RowId): GuidString | undefined;
        // (undocumented)
        getModelSelector(args: ViewStoreRpc.NameOrId & ViewStoreRpc.QueryBindings): Promise<ModelSelectorProps>;
        // @internal
        getModelSelectorRow(id: RowId): SelectorRow | undefined;
        // (undocumented)
        getModelSelectorSync(args: ViewStoreRpc.NameOrId & ViewStoreRpc.QueryBindings): ModelSelectorProps;
        // @internal (undocumented)
        getSearch(id: RowId): SearchRow | undefined;
        // @internal (undocumented)
        getTag(id: RowId): TagRow | undefined;
        getTagsForView(viewId: RowIdOrString): ViewStoreRpc.TagName[] | undefined;
        // (undocumented)
        getThumbnail(args: {
            viewId: RowIdOrString;
        }): Promise<ThumbnailProps | undefined>;
        // @internal (undocumented)
        getThumbnailRow(viewId: RowId): undefined | ThumbnailRow;
        // (undocumented)
        getThumbnailSync(args: {
            viewId: RowIdOrString;
        }): ThumbnailProps | undefined;
        // (undocumented)
        getTimeline(args: ViewStoreRpc.NameOrId): Promise<RenderTimelineProps>;
        // @internal (undocumented)
        getTimelineRow(id: RowId): TimelineRow | undefined;
        // (undocumented)
        getTimelineSync(args: ViewStoreRpc.NameOrId): RenderTimelineProps;
        // (undocumented)
        getViewByName(arg: {
            name: ViewStoreRpc.ViewName;
            groupId?: RowIdOrString;
        }): Promise<ViewStoreRpc.ViewInfo | undefined>;
        // (undocumented)
        getViewByNameSync(arg: {
            name: ViewStoreRpc.ViewName;
            groupId?: RowIdOrString;
        }): ViewStoreRpc.ViewInfo | undefined;
        // (undocumented)
        getViewDefinition(args: {
            viewId: RowIdOrString;
        }): Promise<ViewDefinitionProps>;
        // (undocumented)
        getViewDefinitionSync(args: {
            viewId: RowIdOrString;
        }): ViewDefinitionProps;
        // @internal (undocumented)
        getViewGroup(id: RowId): ViewGroupRow | undefined;
        // @internal (undocumented)
        getViewGroupByName(name: string, parentId: RowId): RowId;
        // (undocumented)
        getViewGroupInfo(args: {
            groupId?: ViewStoreRpc.IdString;
        }): Promise<ViewStoreRpc.ViewGroupInfo | undefined>;
        // (undocumented)
        getViewGroups(args: {
            parent?: ViewStoreRpc.ViewGroupSpec;
        }): Promise<{
            id: string;
            name: string;
        }[]>;
        // (undocumented)
        getViewInfo(args: {
            viewId: RowIdOrString;
        }): Promise<ViewStoreRpc.ViewInfo | undefined>;
        // @internal
        getViewRow(viewId: RowId): undefined | ViewRow;
        // (undocumented)
        get guidMap(): IModelDb.GuidMapper;
        set guidMap(guidMap: IModelDb.GuidMapper);
        // (undocumented)
        get iModel(): IModelDb;
        set iModel(iModel: IModelDb);
        // @internal (undocumented)
        iterateGuids(rowIds: RowId[], fn: (guid: GuidString, row: RowId) => void): void;
        // (undocumented)
        myVersion: string;
        // (undocumented)
        queryViews(queryParams: ViewStoreRpc.QueryParams): Promise<ViewStoreRpc.ViewInfo[]>;
        // (undocumented)
        queryViewsSync(queryParams: ViewStoreRpc.QueryParams): ViewStoreRpc.ViewInfo[];
        // (undocumented)
        removeTagFromView(args: {
            viewId: RowIdOrString;
            tag: string;
        }): Promise<void>;
        // (undocumented)
        renameCategorySelector(args: {
            id: RowIdOrString;
            name?: string;
        }): Promise<void>;
        // (undocumented)
        renameDisplayStyle(args: {
            id: RowIdOrString;
            name?: string;
        }): Promise<void>;
        // (undocumented)
        renameModelSelector(args: {
            id: RowIdOrString;
            name?: string;
        }): Promise<void>;
        // (undocumented)
        renameSearch(args: {
            id: RowIdOrString;
            name: string;
        }): Promise<void>;
        // (undocumented)
        renameTag(args: {
            oldName: string;
            newName: string;
        }): Promise<void>;
        // (undocumented)
        renameTimeline(args: {
            id: RowIdOrString;
            name?: string;
        }): Promise<void>;
        // (undocumented)
        renameView(args: {
            viewId: RowIdOrString;
            name: string;
        }): Promise<void>;
        // (undocumented)
        renameViewGroup(args: {
            groupId: RowIdOrString;
            name: string;
        }): Promise<void>;
        // (undocumented)
        updateCategorySelector(args: ViewStoreRpc.NameOrId & {
            selector: ViewStoreRpc.SelectorProps;
        }): Promise<void>;
        // @internal (undocumented)
        updateCategorySelectorJson(categorySelectorId: RowIdOrString, json: string): void;
        // (undocumented)
        updateDisplayStyle(args: ViewStoreRpc.NameOrId & {
            className: string;
            settings: DisplayStyleSettingsProps;
        }): Promise<void>;
        // @internal (undocumented)
        updateDisplayStyleJson(styleId: RowId, json: string): void;
        // (undocumented)
        updateModelSelector(args: ViewStoreRpc.NameOrId & {
            selector: ViewStoreRpc.SelectorProps;
        }): Promise<void>;
        // @internal (undocumented)
        updateModelSelectorJson(modelSelectorId: RowIdOrString, json: string): void;
        // @internal (undocumented)
        updateSearchJson(searchId: RowId, json: string): void;
        // (undocumented)
        updateTimeline(args: ViewStoreRpc.NameOrId & {
            timeline: RenderSchedule.ScriptProps;
        }): Promise<void>;
        // @internal (undocumented)
        updateTimelineJson(timelineId: RowId, json: string): void;
        // (undocumented)
        updateViewDefinition(args: {
            viewId: RowIdOrString;
            viewDefinition: ViewDefinitionProps;
        }): Promise<void>;
        // @internal (undocumented)
        updateViewGroupJson(groupId: RowIdOrString, json: string): void;
        // (undocumented)
        updateViewShared(arg: {
            viewId: RowIdOrString;
            isShared: boolean;
            owner?: string;
        }): Promise<void>;
    }
    // (undocumented)
    export interface ViewDbCtorArgs {
        // (undocumented)
        guidMap?: IModelDb.GuidMapper;
        // (undocumented)
        iModel?: IModelDb;
    }
    export interface ViewGroupRow extends MarkRequired<TableRow, "name"> {
        // (undocumented)
        defaultViewId?: RowId;
        // (undocumented)
        parentId: RowId;
    }
    export interface ViewRow extends MarkRequired<TableRow, "name"> {
        // (undocumented)
        categorySel: RowId;
        // (undocumented)
        className: string;
        // (undocumented)
        displayStyle: RowId;
        // (undocumented)
        groupId: RowId;
        // (undocumented)
        isPrivate?: boolean;
        // (undocumented)
        modelSel?: RowId;
    }
    export type ViewStoreCtorProps = CloudSqlite.ContainerAccessProps & ViewDbCtorArgs;
    export {};
}

// @public @preview
export class VolumeElement extends SpatialLocationElement {
    protected constructor(props: GeometricElement3dProps, iModel: IModelDb);
    // (undocumented)
    static get className(): string;
}

// @public @preview
export class WebMercatorModel extends SpatialModel {
    // (undocumented)
    static get className(): string;
}

// @beta
export interface Workspace {
    // @internal (undocumented)
    [_implementationProhibited]: unknown;
    // @internal
    readonly containerDir: LocalDirName;
    // @internal
    findContainer(containerId: WorkspaceContainerId): WorkspaceContainer | undefined;
    getCloudCache(): CloudSqlite.CloudCache;
    getContainer(props: GetWorkspaceContainerArgs): WorkspaceContainer;
    getContainerAsync(props: WorkspaceContainerProps): Promise<WorkspaceContainer>;
    getWorkspaceDb(props: WorkspaceDbCloudProps): Promise<WorkspaceDb>;
    getWorkspaceDbs(args: Workspace.DbListOrSettingName & {
        problems?: WorkspaceDbLoadError[];
        filter?: Workspace.DbListFilter;
    }): Promise<WorkspaceDb[]>;
    loadSettingsDictionary(
    props: WorkspaceDbSettingsProps | WorkspaceDbSettingsProps[],
    problems?: WorkspaceDbLoadError[]): Promise<void>;
    resolveWorkspaceDbSetting(
    settingName: SettingName,
    filter?: Workspace.DbListFilter): WorkspaceDbCloudProps[];
    readonly settings: Settings;
}

// @beta (undocumented)
export namespace Workspace {
    let exceptionDiagnosticFn: (e: WorkspaceDbLoadErrors) => void;
    export type DbListFilter = (
    dbProp: WorkspaceDbCloudProps,
    dict: SettingsDictionary) => boolean;
    let onSettingsDictionaryLoadedFn: (loaded: SettingsDictionaryLoaded) => void;
    export type DbListOrSettingName = {
        readonly dbs: WorkspaceDbCloudProps[];
        readonly settingName?: never;
    } | {
        readonly settingName: SettingName;
        readonly dbs?: never;
    };
    export function getBlobResource(args: GetWorkspaceResourceArgs): Uint8Array | undefined;
    export function getStringResource(args: GetWorkspaceResourceArgs): string | undefined;
    export function queryResources(args: QueryWorkspaceResourcesArgs): void;
    export interface SettingsDictionaryLoaded {
        dict: SettingsDictionary;
        from: WorkspaceDb;
    }
}

// @beta
export interface WorkspaceContainer {
    // @internal (undocumented)
    [_implementationProhibited]: unknown;
    // @internal (undocumented)
    addWorkspaceDb(toAdd: WorkspaceDb): void;
    // @internal
    closeWorkspaceDb(container: WorkspaceDb): void;
    readonly cloudContainer?: CloudSqlite.CloudContainer;
    // @internal
    readonly filesDir: LocalDirName;
    readonly fromProps: WorkspaceContainerProps;
    getWorkspaceDb(props?: WorkspaceDbProps): WorkspaceDb;
    resolveDbFileName(props: WorkspaceDbProps): WorkspaceDbFullName;
    readonly workspace: Workspace;
}

// @beta
export type WorkspaceContainerId = string;

// @beta
export interface WorkspaceContainerProps extends Optional<CloudSqlite.ContainerAccessProps, "accessToken"> {
    readonly description?: string;
    readonly loadingHelp?: string;
    readonly syncOnConnect?: boolean;
}

// @beta
export interface WorkspaceDb {
    // @internal (undocumented)
    [_implementationProhibited]: unknown;
    close(): void;
    readonly container: WorkspaceContainer;
    readonly dbFileName: string;
    readonly dbName: WorkspaceDbName;
    getBlob(rscName: WorkspaceResourceName): Uint8Array | undefined;
    // @internal
    getBlobReader(rscName: WorkspaceResourceName): SQLiteDb.BlobIO;
    getFile(rscName: WorkspaceResourceName, targetFileName?: LocalFileName): LocalFileName | undefined;
    getString(rscName: WorkspaceResourceName): string | undefined;
    readonly isOpen: boolean;
    readonly manifest: WorkspaceDbManifest;
    readonly onClose: BeEvent<() => void>;
    open(): void;
    prefetch(opts?: CloudSqlite.PrefetchProps): CloudSqlite.CloudPrefetch;
    // @internal (undocumented)
    queryFileResource(rscName: WorkspaceResourceName): {
        localFileName: LocalFileName;
        info: IModelJsNative.EmbedFileQuery;
    } | undefined;
    queryResources(args: WorkspaceDbQueryResourcesArgs): void;
    readonly sqliteDb: SQLiteDb;
    readonly version: WorkspaceDbVersion;
}

// @beta
export type WorkspaceDbCloudProps = WorkspaceDbProps & WorkspaceContainerProps;

// @beta
export type WorkspaceDbFullName = string;

// @beta
export interface WorkspaceDbLoadError extends ITwinError {
    wsDb?: WorkspaceDb;
    wsDbProps?: WorkspaceDbProps & Partial<WorkspaceDbCloudProps>;
}

// @beta
export interface WorkspaceDbLoadErrors extends ITwinError {
    wsLoadErrors?: WorkspaceDbLoadError[];
}

// @beta
export interface WorkspaceDbManifest {
    readonly contactName?: string;
    readonly description?: string;
    readonly lastEditedBy?: string;
    readonly workspaceName: string;
}

// @beta
export type WorkspaceDbName = string;

// @beta
export type WorkspaceDbNameAndVersion = Optional<CloudSqlite.DbNameAndVersion, "dbName">;

// @beta
export interface WorkspaceDbProps extends WorkspaceDbNameAndVersion {
    readonly includePrerelease?: boolean;
    readonly prefetch?: boolean;
}

// @beta
export interface WorkspaceDbQueryResourcesArgs {
    callback: WorkspaceDbQueryResourcesCallback;
    nameCompare?: "GLOB" | "LIKE" | "NOT GLOB" | "NOT LIKE" | "=" | "<" | ">";
    namePattern?: string;
    type?: "string" | "blob";
}

// @beta
export type WorkspaceDbQueryResourcesCallback = (resourceNames: Iterable<string>) => void;

// @beta
export interface WorkspaceDbSettingsProps extends WorkspaceDbCloudProps {
    priority: SettingsPriority;
    resourceName: string;
}

// @beta
export type WorkspaceDbVersion = CloudSqlite.DbVersion;

// @beta
export type WorkspaceDbVersionRange = CloudSqlite.DbVersionRange;

// @beta (undocumented)
export namespace WorkspaceEditor {
    export function construct(): WorkspaceEditor;
    export function createEmptyDb(args: {
        localFileName: LocalFileName;
        manifest: WorkspaceDbManifest;
    }): void;
}

// @beta
export interface WorkspaceEditor {
    // @internal (undocumented)
    [_implementationProhibited]: unknown;
    close(): void;
    createNewCloudContainer(args: CreateNewWorkspaceContainerArgs): Promise<EditableWorkspaceContainer>;
    getContainer(args: GetWorkspaceContainerArgs): EditableWorkspaceContainer;
    getContainerAsync(props: WorkspaceContainerProps): Promise<EditableWorkspaceContainer>;
    readonly workspace: Workspace;
}

// @beta
export interface WorkspaceOpts {
    containerDir?: LocalDirName;
    settingsFiles?: LocalFileName | LocalFileName[];
}

// @beta
export type WorkspaceResourceName = string;

// @beta
export namespace WorkspaceSettingNames {
    const settingsWorkspaces: string;
}

// (No @packageDocumentation comment for this package)

```