@qlever-llc/trellis 0.7.0-rc.5 → 0.7.0

package/script/js/packages/trellis/npm/src/contract_support/mod.d.ts

@@ -0,0 +1,622 @@
+import { type Static, type TObject, type TProperties, type TSchema } from "typebox";
+import type { BaseError } from "@qlever-llc/result";
+import { TrellisError } from "../errors/TrellisError.js";
+import { canonicalizeJson, digestJson, isJsonValue, type JsonValue } from "./canonical.js";
+import { type EventDesc, type InferRuntimeRpcError, type InferSchemaType, type OperationDesc, type RPCDesc, type RpcErrorClass, type RuntimeRpcErrorDesc, type Schema, schema, type SchemaLike, type SubjectDesc, type TransportErrorData, type TrellisAPI, unwrapSchema } from "./runtime.js";
+import { type SubjectParam } from "./schema_pointers.js";
+export { ContractJobQueueResourceSchema, ContractJobsResourceSchema, ContractKvResourceSchema, ContractResourceBindingsSchema, ContractResourcesSchema, ContractSchemaRefSchema, ContractStoreResourceSchema, ContractStreamResourceSchema, type EventHeader, EventHeaderSchema, type InstalledServiceContract, InstalledServiceContractSchema, IsoDateSchema, type JobsQueueBinding, JobsQueueBindingSchema, type JobsResourceBinding, JobsResourceBindingSchema, type KvResourceBinding, KvResourceBindingSchema, type Paginated, PaginatedSchema, type StoreResourceBinding, StoreResourceBindingSchema, type StreamResourceBinding, StreamResourceBindingSchema, } from "./protocol.js";
+export declare const CONTRACT_FORMAT_V1: "trellis.contract.v1";
+export declare const CATALOG_FORMAT_V1: "trellis.catalog.v1";
+type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (value: infer I) => void ? I : never;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type StringKeyOf<T> = Extract<keyof T, string>;
+type KeysFromList<T> = T extends readonly (infer K)[] ? Extract<K, string> : never;
+declare const DEFINED_ERROR_PAYLOAD: unique symbol;
+export type ContractManifestMetadata = {
+    displayName: string;
+    description: string;
+};
+export type ContractKind = "service" | "app" | "portal" | "device" | "cli";
+export type Capability = string;
+export type JsonSchema = JsonValue | boolean;
+export type ContractSchemaRef<TSchemaName extends string = string> = {
+    schema: TSchemaName;
+};
+export type BuiltinContractErrorName = "UnexpectedError" | "AuthError" | "ValidationError" | "KVError" | "StoreError" | "TransferError";
+type ErrorNameOf<TErrors> = Extract<keyof NonNullable<TErrors>, string> | BuiltinContractErrorName;
+export type ContractRefBuilder<TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TErrors extends Readonly<Record<string, ErrorClass>> | undefined = undefined> = {
+    schema<const TName extends SchemaNameOf<TSchemas>>(schemaName: TName): ContractSchemaRef<TName>;
+    error<const TName extends ErrorNameOf<TErrors>>(errorName: TName): TName;
+};
+export type ContractSchemas = Record<string, JsonSchema>;
+type ContractIdentityFields = {
+    id: string;
+    displayName: string;
+    description: string;
+};
+export type ContractErrorDecl = {
+    type: string;
+    schema?: ContractSchemaRef;
+};
+export type ContractErrorRef = {
+    type: string;
+};
+export type ContractRpcMethod = {
+    version: `v${number}`;
+    subject: string;
+    input: ContractSchemaRef;
+    output: ContractSchemaRef;
+    capabilities?: {
+        call?: Capability[];
+    };
+    errors?: ContractErrorRef[];
+};
+export type ContractOperation = {
+    version: `v${number}`;
+    subject: string;
+    input: ContractSchemaRef;
+    progress?: ContractSchemaRef;
+    output?: ContractSchemaRef;
+    transfer?: {
+        store: string;
+        key: `/${string}`;
+        contentType?: `/${string}`;
+        metadata?: `/${string}`;
+        expiresInMs?: number;
+        maxBytes?: number;
+    };
+    capabilities?: {
+        call?: Capability[];
+        read?: Capability[];
+        cancel?: Capability[];
+    };
+    cancel?: boolean;
+};
+export type ContractEvent = {
+    version: `v${number}`;
+    subject: string;
+    params?: string[];
+    event: ContractSchemaRef;
+    capabilities?: {
+        publish?: Capability[];
+        subscribe?: Capability[];
+    };
+};
+export type ContractSubject = {
+    subject: string;
+    message?: ContractSchemaRef;
+    capabilities?: {
+        publish?: Capability[];
+        subscribe?: Capability[];
+    };
+};
+export type ContractJobQueueResource = {
+    payload: ContractSchemaRef;
+    result?: ContractSchemaRef;
+    maxDeliver?: number;
+    backoffMs?: number[];
+    ackWaitMs?: number;
+    defaultDeadlineMs?: number;
+    progress?: boolean;
+    logs?: boolean;
+    dlq?: boolean;
+    concurrency?: number;
+};
+export type ContractJobsResource = {
+    queues: Record<string, ContractJobQueueResource>;
+};
+export type ContractKvResource = {
+    purpose: string;
+    required?: boolean;
+    history?: number;
+    ttlMs?: number;
+    maxValueBytes?: number;
+};
+export type ContractStoreResource = {
+    purpose: string;
+    required?: boolean;
+    ttlMs?: number;
+    maxObjectBytes?: number;
+    maxTotalBytes?: number;
+};
+export type ContractStreamResource = {
+    purpose: string;
+    required?: boolean;
+    retention?: "limits" | "interest" | "workqueue";
+    storage?: "file" | "memory";
+    numReplicas?: number;
+    maxAgeMs?: number;
+    maxBytes?: number;
+    maxMsgs?: number;
+    discard?: "old" | "new";
+    subjects: string[];
+    sources?: Array<{
+        fromAlias: string;
+        filterSubject?: string;
+        subjectTransformDest?: string;
+    }>;
+};
+export type ContractResources = {
+    kv?: Record<string, ContractKvResource>;
+    store?: Record<string, ContractStoreResource>;
+    streams?: Record<string, ContractStreamResource>;
+    jobs?: ContractJobsResource;
+};
+export type ContractUsesRpc = {
+    call?: string[];
+};
+export type ContractUsesPubSub = {
+    publish?: string[];
+    subscribe?: string[];
+};
+export type ContractUse = {
+    contract: string;
+    rpc?: ContractUsesRpc;
+    operations?: ContractUsesRpc;
+    events?: ContractUsesPubSub;
+    subjects?: ContractUsesPubSub;
+};
+export type ContractUses = Record<string, ContractUse>;
+export type TrellisContractV1 = {
+    format: typeof CONTRACT_FORMAT_V1;
+    id: string;
+    displayName: string;
+    description: string;
+    kind: ContractKind;
+    schemas?: ContractSchemas;
+    uses?: ContractUses;
+    rpc?: Record<string, ContractRpcMethod>;
+    operations?: Record<string, ContractOperation>;
+    events?: Record<string, ContractEvent>;
+    subjects?: Record<string, ContractSubject>;
+    errors?: Record<string, ContractErrorDecl>;
+    resources?: ContractResources;
+};
+export type TrellisCatalogEntry = {
+    id: string;
+    digest: string;
+    displayName: string;
+    description: string;
+};
+export type TrellisCatalogV1 = {
+    format: typeof CATALOG_FORMAT_V1;
+    contracts: TrellisCatalogEntry[];
+};
+export type ContractSourceErrorDecl<TSchemaName extends string = string> = {
+    type: string;
+    schema?: ContractSchemaRef<TSchemaName>;
+};
+type ExtractErrorClasses<TErrors> = TErrors extends Readonly<Record<string, unknown>> ? {
+    [K in keyof TErrors as TErrors[K] extends ErrorClass ? K : never]: Extract<TErrors[K], ErrorClass>;
+} : undefined;
+export type ErrorClass<TData extends TransportErrorData = TransportErrorData, TError extends BaseError = BaseError, TRuntimeSchema extends TSchema = TSchema> = RpcErrorClass<TData, TError> & {
+    readonly name: string;
+    readonly schema: TRuntimeSchema;
+    readonly type?: string;
+};
+type DefinedErrorPayload<TFields extends TProperties> = Static<TObject<TFields>> & object;
+type DefinedErrorData<TType extends string, TFields extends TProperties> = TransportErrorData & {
+    type: TType;
+} & DefinedErrorPayload<TFields>;
+type DefinedErrorSchema = TObject<TProperties>;
+type DefinedErrorPayloadCarrier<TPayload extends object> = {
+    [DEFINED_ERROR_PAYLOAD]: Readonly<TPayload>;
+};
+export type DefineErrorOptions<TType extends string, TFields extends TProperties> = {
+    type: TType;
+    fields: TFields;
+    message: string | ((payload: Readonly<DefinedErrorPayload<TFields>>) => string);
+};
+export type DefinedErrorInit<TFields extends TProperties> = DefinedErrorPayload<TFields> & ErrorOptions & {
+    context?: Record<string, unknown>;
+    id?: string;
+    traceId?: string;
+};
+export type DefinedErrorInstance<TType extends string, TFields extends TProperties> = TrellisError<DefinedErrorData<TType, TFields>> & DefinedErrorPayloadCarrier<DefinedErrorPayload<TFields>> & Readonly<DefinedErrorPayload<TFields>>;
+export type DefinedErrorClass<TType extends string, TFields extends TProperties> = ErrorClass<DefinedErrorData<TType, TFields>, DefinedErrorInstance<TType, TFields>, DefinedErrorSchema> & {
+    new (options: DefinedErrorInit<TFields>): DefinedErrorInstance<TType, TFields>;
+    readonly type: TType;
+    readonly schema: DefinedErrorSchema;
+    fromSerializable(data: DefinedErrorData<TType, TFields>): DefinedErrorInstance<TType, TFields>;
+};
+export type ContractSourceSchemas = Record<string, TSchema>;
+export type ContractSourceRpcMethod<TSchemaName extends string = string, TErrorName extends string = string> = {
+    version: `v${number}`;
+    input: ContractSchemaRef<TSchemaName>;
+    output: ContractSchemaRef<TSchemaName>;
+    capabilities?: {
+        call?: readonly Capability[];
+    };
+    errors?: readonly TErrorName[];
+    authRequired?: boolean;
+    subject?: string;
+};
+export type ContractSourceOperation<TSchemaName extends string = string> = {
+    version: `v${number}`;
+    input: ContractSchemaRef<TSchemaName>;
+    progress?: ContractSchemaRef<TSchemaName>;
+    output?: ContractSchemaRef<TSchemaName>;
+    transfer?: {
+        store: string;
+        key: `/${string}`;
+        contentType?: `/${string}`;
+        metadata?: `/${string}`;
+        expiresInMs?: number;
+        maxBytes?: number;
+    };
+    capabilities?: {
+        call?: readonly Capability[];
+        read?: readonly Capability[];
+        cancel?: readonly Capability[];
+    };
+    cancel?: boolean;
+    subject?: string;
+};
+export type ContractSourceEvent<TSchemaName extends string = string> = {
+    version: `v${number}`;
+    event: ContractSchemaRef<TSchemaName>;
+    params?: readonly SubjectParam[];
+    capabilities?: {
+        publish?: readonly Capability[];
+        subscribe?: readonly Capability[];
+    };
+    subject?: string;
+};
+export type ContractSourceSubject<TSchemaName extends string = string> = {
+    subject: string;
+    message?: ContractSchemaRef<TSchemaName>;
+    capabilities?: {
+        publish?: readonly Capability[];
+        subscribe?: readonly Capability[];
+    };
+};
+export type ContractSourceJobQueueResource<TSchemaName extends string = string> = {
+    payload: ContractSchemaRef<TSchemaName>;
+    result?: ContractSchemaRef<TSchemaName>;
+    maxDeliver?: number;
+    backoffMs?: readonly number[];
+    ackWaitMs?: number;
+    defaultDeadlineMs?: number;
+    progress?: boolean;
+    logs?: boolean;
+    dlq?: boolean;
+    concurrency?: number;
+};
+export type ContractSourceJobsResource<TSchemaName extends string = string> = {
+    queues: Record<string, ContractSourceJobQueueResource<TSchemaName>>;
+};
+export type ContractSourceKvResource = {
+    purpose: string;
+    required?: boolean;
+    history?: number;
+    ttlMs?: number;
+    maxValueBytes?: number;
+};
+export type ContractSourceStoreResource = {
+    purpose: string;
+    required?: boolean;
+    ttlMs?: number;
+    maxObjectBytes?: number;
+    maxTotalBytes?: number;
+};
+export type ContractSourceStreamResource = {
+    purpose: string;
+    required?: boolean;
+    subjects: readonly string[];
+    retention?: "limits" | "interest" | "workqueue";
+    storage?: "file" | "memory";
+    numReplicas?: number;
+    maxAgeMs?: number;
+    maxBytes?: number;
+    maxMsgs?: number;
+    discard?: "old" | "new";
+    sources?: ReadonlyArray<{
+        fromAlias: string;
+        filterSubject?: string;
+        subjectTransformDest?: string;
+    }>;
+};
+export type ContractSourceResources<TSchemaName extends string = string> = {
+    kv?: Record<string, ContractSourceKvResource>;
+    store?: Record<string, ContractSourceStoreResource>;
+    streams?: Record<string, ContractSourceStreamResource>;
+    jobs?: ContractSourceJobsResource<TSchemaName>;
+};
+export type ContractSourceUse = {
+    contract: string;
+    rpc?: {
+        call?: readonly string[];
+    };
+    operations?: {
+        call?: readonly string[];
+    };
+    events?: {
+        publish?: readonly string[];
+        subscribe?: readonly string[];
+    };
+    subjects?: {
+        publish?: readonly string[];
+        subscribe?: readonly string[];
+    };
+};
+export type TrellisContractSource = {
+    id: string;
+    displayName: string;
+    description: string;
+    kind: ContractKind;
+    schemas?: ContractSourceSchemas;
+    uses?: Record<string, ContractSourceUse>;
+    rpc?: Record<string, ContractSourceRpcMethod>;
+    operations?: Record<string, ContractSourceOperation>;
+    events?: Record<string, ContractSourceEvent>;
+    subjects?: Record<string, ContractSourceSubject>;
+    errors?: Record<string, ContractSourceErrorDecl>;
+    resources?: ContractSourceResources;
+};
+export type TrellisApiLike = {
+    rpc: Record<string, RPCDesc>;
+    operations: Record<string, OperationDesc>;
+    events: Record<string, EventDesc>;
+    subjects: Record<string, SubjectDesc>;
+};
+type ApiShape = {
+    rpc: Record<string, unknown>;
+    operations: Record<string, unknown>;
+    events: Record<string, unknown>;
+    subjects: Record<string, unknown>;
+};
+export type EmptyApi = {
+    rpc: {};
+    operations: {};
+    events: {};
+    subjects: {};
+};
+export type ContractApiViews<TOwnedApi extends ApiShape, TUsedApi extends ApiShape, TTrellisApi extends ApiShape> = {
+    owned: TOwnedApi;
+    used: TUsedApi;
+    trellis: TTrellisApi;
+};
+export type UseSpec<TApi extends ApiShape> = {
+    rpc?: {
+        call?: readonly StringKeyOf<TApi["rpc"]>[];
+    };
+    operations?: {
+        call?: readonly StringKeyOf<TApi["operations"]>[];
+    };
+    events?: {
+        publish?: readonly StringKeyOf<TApi["events"]>[];
+        subscribe?: readonly StringKeyOf<TApi["events"]>[];
+    };
+    subjects?: {
+        publish?: readonly StringKeyOf<TApi["subjects"]>[];
+        subscribe?: readonly StringKeyOf<TApi["subjects"]>[];
+    };
+};
+type UseRpcCall<TSpec> = NonNullable<TSpec extends {
+    rpc?: infer TRpc;
+} ? TRpc : never> extends {
+    call?: infer TCall;
+} ? TCall : never;
+type UseEventsPublish<TSpec> = NonNullable<TSpec extends {
+    events?: infer TEvents;
+} ? TEvents : never> extends {
+    publish?: infer TPublish;
+} ? TPublish : never;
+type UseOperationsCall<TSpec> = NonNullable<TSpec extends {
+    operations?: infer TOperations;
+} ? TOperations : never> extends {
+    call?: infer TCall;
+} ? TCall : never;
+type UseEventsSubscribe<TSpec> = NonNullable<TSpec extends {
+    events?: infer TEvents;
+} ? TEvents : never> extends {
+    subscribe?: infer TSubscribe;
+} ? TSubscribe : never;
+type UseSubjectsPublish<TSpec> = NonNullable<TSpec extends {
+    subjects?: infer TSubjects;
+} ? TSubjects : never> extends {
+    publish?: infer TPublish;
+} ? TPublish : never;
+type UseSubjectsSubscribe<TSpec> = NonNullable<TSpec extends {
+    subjects?: infer TSubjects;
+} ? TSubjects : never> extends {
+    subscribe?: infer TSubscribe;
+} ? TSubscribe : never;
+export type ContractDependencyUse<TContractId extends string, TApi extends ApiShape, TSpec extends UseSpec<TApi> = UseSpec<TApi>> = {
+    contract: TContractId;
+    rpc?: {
+        call?: UseRpcCall<TSpec>;
+    };
+    operations?: {
+        call?: UseOperationsCall<TSpec>;
+    };
+    events?: {
+        publish?: UseEventsPublish<TSpec>;
+        subscribe?: UseEventsSubscribe<TSpec>;
+    };
+    subjects?: {
+        publish?: UseSubjectsPublish<TSpec>;
+        subscribe?: UseSubjectsSubscribe<TSpec>;
+    };
+};
+type AuthorContractDependencyUse = ContractDependencyUse<string, TrellisApiLike, any>;
+export type ContractUseFn<TContractId extends string, TApi extends ApiShape> = <const TRpcCall extends readonly StringKeyOf<TApi["rpc"]>[] | undefined = undefined, const TOperationsCall extends readonly StringKeyOf<TApi["operations"]>[] | undefined = undefined, const TEventsPublish extends readonly StringKeyOf<TApi["events"]>[] | undefined = undefined, const TEventsSubscribe extends readonly StringKeyOf<TApi["events"]>[] | undefined = undefined, const TSubjectsPublish extends readonly StringKeyOf<TApi["subjects"]>[] | undefined = undefined, const TSubjectsSubscribe extends readonly StringKeyOf<TApi["subjects"]>[] | undefined = undefined>(spec: {
+    rpc?: {
+        call?: TRpcCall;
+    };
+    operations?: {
+        call?: TOperationsCall;
+    };
+    events?: {
+        publish?: TEventsPublish;
+        subscribe?: TEventsSubscribe;
+    };
+    subjects?: {
+        publish?: TSubjectsPublish;
+        subscribe?: TSubjectsSubscribe;
+    };
+}) => ContractDependencyUse<TContractId, TApi>;
+type MergeRecordUnion<U> = [U] extends [never] ? {} : Simplify<UnionToIntersection<U>>;
+type SchemaNameOf<TSchemas> = Extract<keyof NonNullable<TSchemas>, string>;
+type ResolveSchemaFromMap<TSchemas, TRef> = TRef extends {
+    schema: infer TName;
+} ? TName extends SchemaNameOf<TSchemas> ? NonNullable<TSchemas>[TName] extends TSchema ? Schema<import("./runtime.js").InferSchemaType<NonNullable<TSchemas>[TName]>> : Schema<unknown> : Schema<unknown> : Schema<unknown>;
+type ProjectedRpcMethod<TMethod extends ContractSourceRpcMethod, TSchemas, _TErrors> = {
+    subject: string;
+    input: ResolveSchemaFromMap<TSchemas, TMethod["input"]>;
+    output: ResolveSchemaFromMap<TSchemas, TMethod["output"]>;
+    callerCapabilities: readonly string[];
+    authRequired?: boolean;
+    errors?: TMethod["errors"];
+    runtimeErrors?: readonly RuntimeRpcErrorDesc[];
+    declaredErrorTypes?: readonly string[];
+};
+type ProjectedRpc<T extends Readonly<Record<string, ContractSourceRpcMethod>> | undefined, TSchemas, TErrors> = T extends Readonly<Record<string, ContractSourceRpcMethod>> ? {
+    [K in keyof T]: ProjectedRpcMethod<T[K], TSchemas, TErrors>;
+} : {};
+type ProjectedOperations<T extends Readonly<Record<string, ContractSourceOperation>> | undefined, TSchemas> = T extends Readonly<Record<string, ContractSourceOperation>> ? {
+    [K in keyof T]: OperationDesc<ResolveSchemaFromMap<TSchemas, T[K]["input"]>, ResolveSchemaFromMap<TSchemas, T[K]["progress"]>, ResolveSchemaFromMap<TSchemas, T[K]["output"]>> & (T[K]["transfer"] extends undefined ? {} : {
+        transfer: T[K]["transfer"];
+    });
+} : {};
+type ProjectedEvents<T extends Readonly<Record<string, ContractSourceEvent>> | undefined, TSchemas> = T extends Readonly<Record<string, ContractSourceEvent>> ? {
+    [K in keyof T]: EventDesc<ResolveSchemaFromMap<TSchemas, T[K]["event"]>>;
+} : {};
+type ProjectedSubjects<T extends Readonly<Record<string, ContractSourceSubject>> | undefined, TSchemas> = T extends Readonly<Record<string, ContractSourceSubject>> ? {
+    [K in keyof T]: SubjectDesc<ResolveSchemaFromMap<TSchemas, T[K]["message"]>>;
+} : {};
+export type OwnedApiFromSource<T extends {
+    schemas?: Readonly<Record<string, TSchema>>;
+    errors?: Readonly<Record<string, ErrorClass>>;
+    rpc?: Readonly<Record<string, ContractSourceRpcMethod>>;
+    operations?: Readonly<Record<string, ContractSourceOperation>>;
+    events?: Readonly<Record<string, ContractSourceEvent>>;
+    subjects?: Readonly<Record<string, ContractSourceSubject>>;
+}> = {
+    rpc: ProjectedRpc<T["rpc"], T["schemas"], T["errors"]>;
+    operations: ProjectedOperations<T["operations"], T["schemas"]>;
+    events: ProjectedEvents<T["events"], T["schemas"]>;
+    subjects: ProjectedSubjects<T["subjects"], T["schemas"]>;
+};
+type RpcKeysFromSpec<TSpec> = TSpec extends {
+    rpc?: {
+        call?: infer TCall;
+    };
+} ? KeysFromList<TCall> : never;
+type EventKeysFromSpec<TSpec> = (TSpec extends {
+    events?: {
+        publish?: infer TPublish;
+    };
+} ? KeysFromList<TPublish> : never) | (TSpec extends {
+    events?: {
+        subscribe?: infer TSubscribe;
+    };
+} ? KeysFromList<TSubscribe> : never);
+type OperationKeysFromSpec<TSpec> = TSpec extends {
+    operations?: {
+        call?: infer TCall;
+    };
+} ? KeysFromList<TCall> : never;
+type SubjectKeysFromSpec<TSpec> = (TSpec extends {
+    subjects?: {
+        publish?: infer TPublish;
+    };
+} ? KeysFromList<TPublish> : never) | (TSpec extends {
+    subjects?: {
+        subscribe?: infer TSubscribe;
+    };
+} ? KeysFromList<TSubscribe> : never);
+type ApiFromDependencyUse<TUse> = TUse extends ContractDependencyUse<string, infer TApi, infer TSpec> ? {
+    rpc: Pick<TApi["rpc"], RpcKeysFromSpec<TSpec>>;
+    operations: Pick<TApi["operations"], OperationKeysFromSpec<TSpec>>;
+    events: Pick<TApi["events"], EventKeysFromSpec<TSpec>>;
+    subjects: Pick<TApi["subjects"], SubjectKeysFromSpec<TSpec>>;
+} : EmptyApi;
+export type UsedApiFromUses<TUses> = [TUses] extends [undefined] ? EmptyApi : TUses extends Record<string, unknown> ? {
+    rpc: MergeRecordUnion<ApiFromDependencyUse<TUses[keyof TUses]>["rpc"]>;
+    operations: MergeRecordUnion<ApiFromDependencyUse<TUses[keyof TUses]>["operations"]>;
+    events: MergeRecordUnion<ApiFromDependencyUse<TUses[keyof TUses]>["events"]>;
+    subjects: MergeRecordUnion<ApiFromDependencyUse<TUses[keyof TUses]>["subjects"]>;
+} : EmptyApi;
+export type MergeApis<TOwnedApi extends ApiShape, TUsedApi extends ApiShape> = {
+    rpc: Simplify<TUsedApi["rpc"] & TOwnedApi["rpc"]>;
+    operations: Simplify<TUsedApi["operations"] & TOwnedApi["operations"]>;
+    events: Simplify<TUsedApi["events"] & TOwnedApi["events"]>;
+    subjects: Simplify<TUsedApi["subjects"] & TOwnedApi["subjects"]>;
+};
+export type ContractModule<TContractId extends string, TOwnedApi extends ApiShape, TUsedApi extends ApiShape, TTrellisApi extends ApiShape> = {
+    CONTRACT_ID: TContractId;
+    CONTRACT: TrellisContractV1;
+    CONTRACT_DIGEST: string;
+    API: ContractApiViews<TOwnedApi, TUsedApi, TTrellisApi>;
+    use: ContractUseFn<TContractId, TOwnedApi>;
+};
+export type SdkContractModule<TContractId extends string, TOwnedApi extends ApiShape> = ContractModule<TContractId, TOwnedApi, EmptyApi, TOwnedApi>;
+export type DefinedContract<TOwnedApi extends ApiShape, TUsedApi extends ApiShape, TTrellisApi extends ApiShape, TContractId extends string = string> = ContractModule<TContractId, TOwnedApi, TUsedApi, TTrellisApi>;
+export type DefineContractInput<TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined = undefined, TErrors extends Readonly<Record<string, ErrorClass>> | undefined = undefined, TRpc extends Readonly<Record<string, ContractSourceRpcMethod<SchemaNameOf<TSchemas>, ErrorNameOf<TErrors>>>> | undefined = undefined, TOperations extends Readonly<Record<string, ContractSourceOperation<SchemaNameOf<TSchemas>>>> | undefined = undefined, TEvents extends Readonly<Record<string, ContractSourceEvent<SchemaNameOf<TSchemas>>>> | undefined = undefined, TSubjects extends Readonly<Record<string, ContractSourceSubject<SchemaNameOf<TSchemas>>>> | undefined = undefined> = {
+    id: string;
+    displayName: string;
+    description: string;
+    kind: ContractKind;
+    schemas?: TSchemas;
+    uses?: TUses;
+    errors?: TErrors;
+    rpc?: TRpc;
+    operations?: TOperations;
+    events?: TEvents;
+    subjects?: TSubjects;
+    resources?: ContractSourceResources<SchemaNameOf<TSchemas>>;
+};
+type AnyDefineContractRegistry = {
+    schemas?: Readonly<Record<string, TSchema>>;
+    errors?: Readonly<Record<string, unknown>>;
+};
+type RegistrySchemas<TRegistry extends AnyDefineContractRegistry> = TRegistry extends {
+    schemas?: infer TSchemas;
+} ? TSchemas extends Readonly<Record<string, TSchema>> | undefined ? TSchemas : undefined : undefined;
+type RegistryErrors<TRegistry extends AnyDefineContractRegistry> = TRegistry extends {
+    errors?: infer TErrors;
+} ? TErrors extends Readonly<Record<string, unknown>> | undefined ? ExtractErrorClasses<TErrors> : undefined : undefined;
+type DefineContractBodyInput<TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined = undefined, TErrors extends Readonly<Record<string, ErrorClass>> | undefined = undefined, TRpc extends Readonly<Record<string, ContractSourceRpcMethod<SchemaNameOf<TSchemas>, ErrorNameOf<TErrors>>>> | undefined = undefined, TOperations extends Readonly<Record<string, ContractSourceOperation<SchemaNameOf<TSchemas>>>> | undefined = undefined, TEvents extends Readonly<Record<string, ContractSourceEvent<SchemaNameOf<TSchemas>>>> | undefined = undefined, TSubjects extends Readonly<Record<string, ContractSourceSubject<SchemaNameOf<TSchemas>>>> | undefined = undefined> = Omit<DefineContractInput<TSchemas, TUses, TErrors, TRpc, TOperations, TEvents, TSubjects>, "schemas" | "errors"> & {
+    schemas?: never;
+    errors?: never;
+};
+type ServiceContractBodyInput<TSchemas extends Readonly<Record<string, TSchema>> | undefined = undefined, TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined = undefined, TErrors extends Readonly<Record<string, ErrorClass>> | undefined = undefined, TRpc extends Readonly<Record<string, ContractSourceRpcMethod<SchemaNameOf<TSchemas>, ErrorNameOf<TErrors>>>> | undefined = undefined, TOperations extends Readonly<Record<string, ContractSourceOperation<SchemaNameOf<TSchemas>>>> | undefined = undefined, TEvents extends Readonly<Record<string, ContractSourceEvent<SchemaNameOf<TSchemas>>>> | undefined = undefined, TSubjects extends Readonly<Record<string, ContractSourceSubject<SchemaNameOf<TSchemas>>>> | undefined = undefined> = Omit<DefineContractBodyInput<TSchemas, TUses, TErrors, TRpc, TOperations, TEvents, TSubjects>, "kind"> & {
+    kind?: never;
+};
+type ClientContractBodyInput<TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined = undefined> = ContractIdentityFields & {
+    uses?: TUses;
+    kind?: never;
+    schemas?: never;
+    errors?: never;
+    rpc?: never;
+    operations?: never;
+    events?: never;
+    subjects?: never;
+    resources?: never;
+};
+type BuiltContractSource<TRegistry extends AnyDefineContractRegistry, TBody extends {
+    id: string;
+}> = Simplify<Omit<TBody, "schemas" | "errors"> & Pick<TRegistry, Extract<keyof TRegistry, "schemas" | "errors">>>;
+type WithKind<TBody extends {
+    id: string;
+}, TKind extends ContractKind> = Simplify<Omit<TBody, "kind"> & {
+    kind: TKind;
+}>;
+/**
+ * Define a transportable Trellis error class from a payload-object schema.
+ *
+ * The returned value is a real runtime error class that carries the wire schema
+ * and reconstruction logic needed by `defineServiceContract(...)`.
+ */
+export declare function defineError<const TType extends string, const TFields extends TProperties>(options: DefineErrorOptions<TType, TFields>): DefinedErrorClass<TType, TFields>;
+export declare function defineServiceContract<const TRegistry extends AnyDefineContractRegistry, const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TRpc extends Readonly<Record<string, ContractSourceRpcMethod<SchemaNameOf<RegistrySchemas<TRegistry>>, ErrorNameOf<RegistryErrors<TRegistry>>>>> | undefined, const TOperations extends Readonly<Record<string, ContractSourceOperation<SchemaNameOf<RegistrySchemas<TRegistry>>>>> | undefined, const TEvents extends Readonly<Record<string, ContractSourceEvent<SchemaNameOf<RegistrySchemas<TRegistry>>>>> | undefined, const TSubjects extends Readonly<Record<string, ContractSourceSubject<SchemaNameOf<RegistrySchemas<TRegistry>>>>> | undefined, const TBody extends ServiceContractBodyInput<RegistrySchemas<TRegistry>, TUses, RegistryErrors<TRegistry>, TRpc, TOperations, TEvents, TSubjects>>(registry: TRegistry, build: (ref: ContractRefBuilder<RegistrySchemas<TRegistry>, RegistryErrors<TRegistry>>) => TBody): DefinedContract<OwnedApiFromSource<BuiltContractSource<TRegistry, WithKind<TBody, "service">>>, UsedApiFromUses<TBody["uses"]>, MergeApis<OwnedApiFromSource<BuiltContractSource<TRegistry, WithKind<TBody, "service">>>, UsedApiFromUses<TBody["uses"]>>, TBody["id"]>;
+export declare function defineAppContract<const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TBody extends ClientContractBodyInput<TUses>>(build: () => TBody): DefinedContract<OwnedApiFromSource<WithKind<TBody, "app">>, UsedApiFromUses<TBody["uses"]>, MergeApis<OwnedApiFromSource<WithKind<TBody, "app">>, UsedApiFromUses<TBody["uses"]>>, TBody["id"]>;
+export declare function definePortalContract<const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TBody extends ClientContractBodyInput<TUses>>(build: () => TBody): DefinedContract<OwnedApiFromSource<WithKind<TBody, "portal">>, UsedApiFromUses<TBody["uses"]>, MergeApis<OwnedApiFromSource<WithKind<TBody, "portal">>, UsedApiFromUses<TBody["uses"]>>, TBody["id"]>;
+export declare function defineCliContract<const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TBody extends ClientContractBodyInput<TUses>>(build: () => TBody): DefinedContract<OwnedApiFromSource<WithKind<TBody, "cli">>, UsedApiFromUses<TBody["uses"]>, MergeApis<OwnedApiFromSource<WithKind<TBody, "cli">>, UsedApiFromUses<TBody["uses"]>>, TBody["id"]>;
+export declare function defineDeviceContract<const TUses extends Readonly<Record<string, AuthorContractDependencyUse>> | undefined, const TBody extends ClientContractBodyInput<TUses>>(build: () => TBody): DefinedContract<OwnedApiFromSource<WithKind<TBody, "device">>, UsedApiFromUses<TBody["uses"]>, MergeApis<OwnedApiFromSource<WithKind<TBody, "device">>, UsedApiFromUses<TBody["uses"]>>, TBody["id"]>;
+export type { EventDesc, InferRuntimeRpcError, InferSchemaType, JsonValue, RPCDesc, RpcErrorClass, RuntimeRpcErrorDesc, Schema, SchemaLike, SubjectDesc, TransportErrorData, TrellisAPI, };
+export { canonicalizeJson, digestJson, isJsonValue, schema, unwrapSchema };
+//# sourceMappingURL=mod.d.ts.map