declare const backendContractBrand: unique symbol;
export type Brand<Value, Kind extends string, Scope extends string = string> = Value & {
    readonly [backendContractBrand]: {
        readonly kind: Kind;
        readonly scope: Scope;
    };
};
export type OpaqueId<Kind extends string, Scope extends string = string> = Brand<string, Kind, Scope>;
export type AttachmentId<Attachment extends string> = OpaqueId<'attachment', Attachment>;
export type AdapterId<Attachment extends string> = OpaqueId<'adapter', Attachment>;
export type BackendInstanceId<Attachment extends string> = OpaqueId<'backend-instance', Attachment>;
export type ManagerId<Attachment extends string, Manager extends string> = OpaqueId<'manager', `${Attachment}:${Manager}`>;
export type GenerationId<Kind extends string, Scope extends string> = OpaqueId<Kind, Scope>;
export type PeerId<Attachment extends string> = OpaqueId<'peer', Attachment>;
export type ConnectionId<Attachment extends string, Connection extends string> = OpaqueId<'connection', `${Attachment}:${Connection}`>;
export type LeaseId<Attachment extends string, Lease extends string> = OpaqueId<'lease', `${Attachment}:${Lease}`>;
export type ScanShareToken<Attachment extends string, Lease extends string> = OpaqueId<'scan-share-token', `${Attachment}:${Lease}`>;
export type ScanSessionId<Attachment extends string, Lease extends string> = OpaqueId<'scan-session', `${Attachment}:${Lease}`>;
export type ClientId<Attachment extends string, Client extends string> = OpaqueId<'client', `${Attachment}:${Client}`>;
export type OperationCorrelation<Attachment extends string, Operation extends string> = OpaqueId<'core-operation', `${Attachment}:${Operation}`>;
export type BackendOperationHandle<Attachment extends string, Operation extends string> = OpaqueId<'backend-operation', `${Attachment}:${Operation}`>;
export type NativeOperationCorrelation<Attachment extends string, Operation extends string> = OpaqueId<'native-operation', `${Attachment}:${Operation}`>;
export type IpcOperationCorrelation<Attachment extends string, Operation extends string> = OpaqueId<'ipc-operation', `${Attachment}:${Operation}`>;
export type GattDatabaseId<Attachment extends string, Connection extends string, Database extends string> = OpaqueId<'gatt-database', `${Attachment}:${Connection}:${Database}`>;
export type SubscriptionId<Attachment extends string, Connection extends string, Database extends string, Service extends string, Characteristic extends string, Subscription extends string> = OpaqueId<'subscription', `${Attachment}:${Connection}:${Database}:${Service}:${Characteristic}:${Subscription}`>;
export type Uuid = Brand<string, 'canonical-uuid'>;
export type OwnedBytes = Brand<Uint8Array, 'owned-bytes'>;
export type BorrowedBytes = Readonly<Uint8Array>;
export type ByteLimit = Brand<number, 'byte-limit'>;
export type MonotonicTimestamp = Brand<number, 'monotonic-timestamp'>;
export type Deadline = Brand<number, 'deadline'>;
export type Capacity = Brand<number, 'capacity'>;
export type ResourceCount = Brand<number, 'resource-count'>;
export type BackendContractAxis = 'backend-contract';
export type CapabilitySchemaAxis = 'capability-schema';
export type EventSchemaAxis = 'event-schema';
export type TraceFormatAxis = 'trace-format';
export type NativeProtocolAxis = 'native-protocol';
export type IpcProtocolAxis = 'ipc-protocol';
export type ProtocolAxis = BackendContractAxis | CapabilitySchemaAxis | EventSchemaAxis | TraceFormatAxis | NativeProtocolAxis | IpcProtocolAxis;
export interface VersionNumber<Axis extends string> {
    readonly axis: Axis;
    readonly value: number;
}
export interface VersionRange<Axis extends string> {
    readonly axis: Axis;
    readonly minimum: VersionNumber<Axis>;
    readonly maximum: VersionNumber<Axis>;
}
export interface NegotiatedVersion<Axis extends string> {
    readonly axis: Axis;
    readonly selected: VersionNumber<Axis>;
    readonly localRange: VersionRange<Axis>;
    readonly remoteRange: VersionRange<Axis>;
}
export interface BackendCompatibilityOffer {
    readonly backendContract: VersionRange<BackendContractAxis>;
    readonly capabilitySchema: VersionRange<CapabilitySchemaAxis>;
    readonly eventSchema: VersionRange<EventSchemaAxis>;
    readonly traceFormat: VersionRange<TraceFormatAxis>;
}
export interface NativeCompatibilityOffer extends BackendCompatibilityOffer {
    readonly nativeProtocol: VersionRange<NativeProtocolAxis>;
}
export interface IpcCompatibilityOffer extends BackendCompatibilityOffer {
    readonly ipcProtocol: VersionRange<IpcProtocolAxis>;
}
export interface CoreVersionAxes {
    readonly backendContract: NegotiatedVersion<BackendContractAxis>;
    readonly capabilitySchema: NegotiatedVersion<CapabilitySchemaAxis>;
    readonly eventSchema: NegotiatedVersion<EventSchemaAxis>;
    readonly traceFormat: NegotiatedVersion<TraceFormatAxis>;
}
export interface NativeVersionAxes extends CoreVersionAxes {
    readonly nativeProtocol: NegotiatedVersion<NativeProtocolAxis>;
}
export interface IpcVersionAxes extends CoreVersionAxes {
    readonly ipcProtocol: NegotiatedVersion<IpcProtocolAxis>;
}
export type HostNeutralVersionAxes = CoreVersionAxes;
export type ApplicableCompatibilityOffer = BackendCompatibilityOffer | NativeCompatibilityOffer | IpcCompatibilityOffer;
export type ApplicableVersionAxes = HostNeutralVersionAxes | NativeVersionAxes | IpcVersionAxes;
export interface ByteLimits {
    readonly maximumOperationBytes: ByteLimit;
    readonly maximumAdvertisementBytes: ByteLimit;
    readonly maximumStreamItemBytes: ByteLimit;
    readonly maximumRetainedBytes: ByteLimit;
}
export interface ByteOwnership {
    readonly input: 'caller-borrows-until-settlement';
    readonly retainedInput: 'backend-copies-before-retention';
    readonly output: 'receiver-owns-independent-copy';
    readonly boundary: 'copy-or-transfer-with-explicit-owner';
}
export interface AttachmentBinding<Attachment extends string> {
    readonly attachmentId: AttachmentId<Attachment>;
    readonly backendInstanceId: BackendInstanceId<Attachment>;
    readonly backendGeneration: GenerationId<'backend-generation', Attachment>;
    readonly adapterId: AdapterId<Attachment>;
    readonly adapterGeneration: GenerationId<'adapter-generation', Attachment>;
}
export interface AttachmentBoundIdFactory<Attachment extends string> {
    clientId(value: string): ClientId<Attachment, string>;
    managerId(value: string): ManagerId<Attachment, string>;
    connectionId(value: string): ConnectionId<Attachment, string>;
    leaseId(value: string): LeaseId<Attachment, string>;
    scanShareToken(value: string): ScanShareToken<Attachment, string>;
    scanSessionId(value: string): ScanSessionId<Attachment, string>;
    databaseId(value: string): GattDatabaseId<Attachment, string, string>;
    subscriptionId(value: string): SubscriptionId<Attachment, string, string, string, string, string>;
    operationCorrelation(value: string): OperationCorrelation<Attachment, string>;
    backendOperationHandle(value: string): BackendOperationHandle<Attachment, string>;
}
export interface IpcOperationIdFactory<Attachment extends string> {
    ipcOperationCorrelation(value: string): IpcOperationCorrelation<Attachment, string>;
    ipcDispatchEpoch(value: string): GenerationId<'ipc-dispatch-epoch', `${Attachment}:${string}`>;
}
type AttachmentFromBoundScope<Scope extends string> = Scope extends `${infer Attachment}:${string}` ? Attachment : never;
export type Scalar = boolean | number | string | null;
export type SerializableValue = Scalar | OwnedBytes | readonly SerializableValue[] | SerializableRecord;
export interface SerializableRecord {
    readonly [key: string]: SerializableValue;
}
export declare function opaqueId<Kind extends string, Scope extends string>(value: string, kind: Kind, scope: Scope): OpaqueId<Kind, Scope>;
/** Creates a peer identifier using the same attachment-bound scope as other runtime identifiers. */
export declare function createAttachmentBoundPeerId<Attachment extends string>(binding: AttachmentBinding<Attachment>, value: string): PeerId<Attachment>;
export declare function createAttachmentBoundIdFactory<Attachment extends string>(binding: AttachmentBinding<Attachment>): AttachmentBoundIdFactory<Attachment>;
/** Creates renderer-local IPC correlation IDs scoped to one already-attached backend generation. */
export declare function createIpcOperationIdFactory<Attachment extends string>(scope: string): IpcOperationIdFactory<Attachment>;
export declare function rebindAttachmentBoundId<Kind extends string, Scope extends string>(id: OpaqueId<Kind, Scope>, source: AttachmentBinding<AttachmentFromBoundScope<Scope>>, target: AttachmentBinding<AttachmentFromBoundScope<Scope>>): OpaqueId<Kind, Scope>;
export declare function canonicalUuid(value: string): Uuid;
/**
 * Canonicalizes a 48-bit BLE radio address to uppercase colon-separated octets.
 * Accepts ':' or '-' separators in any case; rejects every other shape. This
 * canonical form only identifies peers using public or static random addresses;
 * peers using resolvable private addresses have no stable radio address and
 * must be re-entered through a durable `PeerReference` instead.
 */
export declare function canonicalBleAddress(value: string): string;
export declare function byteLimit(value: number): ByteLimit;
export declare function capacity(value: number): Capacity;
export declare function resourceCount(value: number): ResourceCount;
export declare function monotonicTimestamp(value: number): MonotonicTimestamp;
export declare function deadline(value: number): Deadline;
export declare function ownBytes(bytes: BorrowedBytes, maximumBytes: ByteLimit): OwnedBytes;
export declare function version<Axis extends ProtocolAxis>(axis: Axis, value: number): VersionNumber<Axis>;
export declare function versionRange<Axis extends ProtocolAxis>(minimum: VersionNumber<Axis>, maximum: VersionNumber<Axis>): VersionRange<Axis>;
export declare function negotiateVersion<Axis extends ProtocolAxis>(localRange: VersionRange<Axis>, remoteRange: VersionRange<Axis>): NegotiatedVersion<Axis>;
export declare function negotiateCoreVersions(local: BackendCompatibilityOffer, remote: BackendCompatibilityOffer): CoreVersionAxes;
export declare function assertCoreVersionsAccepted(versions: CoreVersionAxes, offer: BackendCompatibilityOffer): void;
export declare function assertIpcVersionsAccepted(versions: IpcVersionAxes, offer: IpcCompatibilityOffer): void;
export declare function applicableVersionAxesEqual(left: ApplicableVersionAxes, right: ApplicableVersionAxes): boolean;
export declare function snapshotApplicableVersionAxes(versions: ApplicableVersionAxes): ApplicableVersionAxes;
export {};
//# sourceMappingURL=primitives.d.ts.map