@oxchannels/sdk 1.0.0

package/dist/generated/agent-bootstrap-contract-v2-schema.d.ts

@@ -0,0 +1,398 @@
+export interface paths {
+    "/v1/device-enrollments/complete": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Device Enrollment complete */
+        post: operations["DeviceEnrollment_complete"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        EnrollmentCompleteResponseDto: {
+            deviceId: string;
+            encryptionKeyId: string;
+            generation: number;
+            /** @description Opaque local profile binding; contains no provider identifier. */
+            profileRef: string;
+            /** @description Reveal-once credential; store only in the OS-backed key store. */
+            refreshCredential: string;
+            signingKeyId: string;
+        };
+        EnrollmentProofDto: {
+            code: string;
+            codeId: string;
+            encryptionJwk: {
+                [key: string]: string;
+            };
+            encryptionProof: string;
+            nonce: string;
+            signingJwk: {
+                [key: string]: string;
+            };
+            signingProof: string;
+            version: number;
+            workspaceId: string;
+        };
+        /** OxChannels ErrorEnvelope v2 */
+        ErrorEnvelopeV2: {
+            /** @enum {unknown} */
+            category: "VALIDATION";
+            /** @enum {unknown} */
+            code: "INVALID_REQUEST";
+            correlationId: string;
+            /** @enum {unknown} */
+            effectEvidence: "NOT_APPLIED";
+            message: string;
+            /** @enum {unknown} */
+            retryable: false;
+            /** @enum {unknown} */
+            schemaVersion: "2.0.0";
+            traceId: string;
+            violations?: {
+                code: string;
+                path: string;
+            }[];
+        } | {
+            /** @enum {unknown} */
+            category: "AUTHENTICATION";
+            /** @enum {unknown} */
+            code: "AUTHENTICATION_REQUIRED";
+            correlationId: string;
+            /** @enum {unknown} */
+            effectEvidence: "NOT_APPLIED";
+            message: string;
+            /** @enum {unknown} */
+            retryable: true;
+            /** @enum {unknown} */
+            schemaVersion: "2.0.0";
+            traceId: string;
+            violations?: {
+                code: string;
+                path: string;
+            }[];
+        } | {
+            /** @enum {unknown} */
+            category: "AUTHORIZATION";
+            /** @enum {unknown} */
+            code: "FORBIDDEN";
+            correlationId: string;
+            /** @enum {unknown} */
+            effectEvidence: "NOT_APPLIED";
+            message: string;
+            /** @enum {unknown} */
+            retryable: false;
+            /** @enum {unknown} */
+            schemaVersion: "2.0.0";
+            traceId: string;
+            violations?: {
+                code: string;
+                path: string;
+            }[];
+        } | {
+            /** @enum {unknown} */
+            category: "RESOURCE";
+            /** @enum {unknown} */
+            code: "NOT_FOUND";
+            correlationId: string;
+            /** @enum {unknown} */
+            effectEvidence: "NOT_APPLIED";
+            message: string;
+            /** @enum {unknown} */
+            retryable: false;
+            /** @enum {unknown} */
+            schemaVersion: "2.0.0";
+            traceId: string;
+            violations?: {
+                code: string;
+                path: string;
+            }[];
+        } | {
+            /** @enum {unknown} */
+            category: "CONFLICT";
+            /** @enum {unknown} */
+            code: "IDEMPOTENCY_CONFLICT";
+            correlationId: string;
+            /** @enum {unknown} */
+            effectEvidence: null;
+            message: string;
+            /** @enum {unknown} */
+            retryable: false;
+            /** @enum {unknown} */
+            schemaVersion: "2.0.0";
+            traceId: string;
+            violations?: {
+                code: string;
+                path: string;
+            }[];
+        } | {
+            /** @enum {unknown} */
+            category: "RATE_LIMIT";
+            /** @enum {unknown} */
+            code: "RATE_LIMITED";
+            correlationId: string;
+            /** @enum {unknown} */
+            effectEvidence: null;
+            message: string;
+            /** @enum {unknown} */
+            retryable: true;
+            retryAfterSeconds: number;
+            /** @enum {unknown} */
+            schemaVersion: "2.0.0";
+            traceId: string;
+            violations?: {
+                code: string;
+                path: string;
+            }[];
+        } | {
+            /** @enum {unknown} */
+            category: "INTERNAL";
+            /** @enum {unknown} */
+            code: "INTERNAL_SAFE_FAILURE";
+            correlationId: string;
+            /** @enum {unknown} */
+            effectEvidence: null;
+            message: string;
+            /** @enum {unknown} */
+            retryable: false;
+            /** @enum {unknown} */
+            schemaVersion: "2.0.0";
+            traceId: string;
+            violations?: {
+                code: string;
+                path: string;
+            }[];
+        } | {
+            /** @enum {unknown} */
+            category: "CONFLICT";
+            /** @enum {unknown} */
+            code: "CONFLICT";
+            correlationId: string;
+            /** @enum {unknown} */
+            effectEvidence: null;
+            message: string;
+            /** @enum {unknown} */
+            retryable: false;
+            /** @enum {unknown} */
+            schemaVersion: "2.0.0";
+            traceId: string;
+            violations?: {
+                code: string;
+                path: string;
+            }[];
+        };
+        ErrorEnvelopeV2AuthenticationRequired: {
+            code: "ErrorEnvelopeV2AuthenticationRequired";
+        } & (Omit<components["schemas"]["ErrorEnvelopeV2"], "code"> & {
+            /** @enum {unknown} */
+            category: "AUTHENTICATION";
+            /** @enum {unknown} */
+            code: "AUTHENTICATION_REQUIRED";
+            correlationId: string;
+            /** @enum {unknown} */
+            effectEvidence: "NOT_APPLIED";
+            message: string;
+            /** @enum {unknown} */
+            retryable: true;
+            /** @enum {unknown} */
+            schemaVersion: "2.0.0";
+            traceId: string;
+            violations?: {
+                code: string;
+                path: string;
+            }[];
+        });
+        ErrorEnvelopeV2Conflict: {
+            code: "ErrorEnvelopeV2Conflict";
+        } & (Omit<components["schemas"]["ErrorEnvelopeV2"], "code"> & {
+            /** @enum {unknown} */
+            category: "CONFLICT";
+            /** @enum {unknown} */
+            code: "CONFLICT";
+            correlationId: string;
+            /** @enum {unknown} */
+            effectEvidence: null;
+            message: string;
+            /** @enum {unknown} */
+            retryable: false;
+            /** @enum {unknown} */
+            schemaVersion: "2.0.0";
+            traceId: string;
+            violations?: {
+                code: string;
+                path: string;
+            }[];
+        });
+        ErrorEnvelopeV2IdempotencyConflict: {
+            code: "ErrorEnvelopeV2IdempotencyConflict";
+        } & (Omit<components["schemas"]["ErrorEnvelopeV2"], "code"> & {
+            /** @enum {unknown} */
+            category: "CONFLICT";
+            /** @enum {unknown} */
+            code: "IDEMPOTENCY_CONFLICT";
+            correlationId: string;
+            /** @enum {unknown} */
+            effectEvidence: null;
+            message: string;
+            /** @enum {unknown} */
+            retryable: false;
+            /** @enum {unknown} */
+            schemaVersion: "2.0.0";
+            traceId: string;
+            violations?: {
+                code: string;
+                path: string;
+            }[];
+        });
+        ErrorEnvelopeV2InternalSafeFailure: {
+            code: "ErrorEnvelopeV2InternalSafeFailure";
+        } & (Omit<components["schemas"]["ErrorEnvelopeV2"], "code"> & {
+            /** @enum {unknown} */
+            category: "INTERNAL";
+            /** @enum {unknown} */
+            code: "INTERNAL_SAFE_FAILURE";
+            correlationId: string;
+            /** @enum {unknown} */
+            effectEvidence: null;
+            message: string;
+            /** @enum {unknown} */
+            retryable: false;
+            /** @enum {unknown} */
+            schemaVersion: "2.0.0";
+            traceId: string;
+            violations?: {
+                code: string;
+                path: string;
+            }[];
+        });
+        ErrorEnvelopeV2InvalidRequest: {
+            code: "ErrorEnvelopeV2InvalidRequest";
+        } & (Omit<components["schemas"]["ErrorEnvelopeV2"], "code"> & {
+            /** @enum {unknown} */
+            category: "VALIDATION";
+            /** @enum {unknown} */
+            code: "INVALID_REQUEST";
+            correlationId: string;
+            /** @enum {unknown} */
+            effectEvidence: "NOT_APPLIED";
+            message: string;
+            /** @enum {unknown} */
+            retryable: false;
+            /** @enum {unknown} */
+            schemaVersion: "2.0.0";
+            traceId: string;
+            violations?: {
+                code: string;
+                path: string;
+            }[];
+        });
+        ErrorEnvelopeV2NotFound: {
+            code: "ErrorEnvelopeV2NotFound";
+        } & (Omit<components["schemas"]["ErrorEnvelopeV2"], "code"> & {
+            /** @enum {unknown} */
+            category: "RESOURCE";
+            /** @enum {unknown} */
+            code: "NOT_FOUND";
+            correlationId: string;
+            /** @enum {unknown} */
+            effectEvidence: "NOT_APPLIED";
+            message: string;
+            /** @enum {unknown} */
+            retryable: false;
+            /** @enum {unknown} */
+            schemaVersion: "2.0.0";
+            traceId: string;
+            violations?: {
+                code: string;
+                path: string;
+            }[];
+        });
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    DeviceEnrollment_complete: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EnrollmentProofDto"];
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EnrollmentCompleteResponseDto"];
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelopeV2InvalidRequest"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelopeV2AuthenticationRequired"];
+                };
+            };
+            /** @description Resource unavailable */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelopeV2NotFound"];
+                };
+            };
+            /** @description State or idempotency conflict */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelopeV2Conflict"] | components["schemas"]["ErrorEnvelopeV2IdempotencyConflict"];
+                };
+            };
+            /** @description Unexpected server failure */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelopeV2InternalSafeFailure"];
+                };
+            };
+        };
+    };
+}

package/dist/generated/agent-bootstrap-contract-v2-schema.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/client.d.ts

@@ -0,0 +1 @@
+export { OXCHANNELS_CONTRACT_SET_VERSION, OxChannelsApiError, OxChannelsApiErrorV2, OxChannelsApiProtocolError, createAgentBootstrapClient, createDashboardContractClient, createDashboardV2Client, createOxStudioClient, createPartnerClient, createPublicClient, } from '../client.js';

package/dist/generated/client.js

@@ -0,0 +1,2 @@
+// Compatibility re-export. Wire types are generated in *-schema.ts; runtime wrappers live in client.ts.
+export { OXCHANNELS_CONTRACT_SET_VERSION, OxChannelsApiError, OxChannelsApiErrorV2, OxChannelsApiProtocolError, createAgentBootstrapClient, createDashboardContractClient, createDashboardV2Client, createOxStudioClient, createPartnerClient, createPublicClient, } from '../client.js';

package/dist/generated/contracts/api-errors.d.ts

@@ -0,0 +1,83 @@
+export declare const PARITY_CONTRACT_SET_VERSION: "2.0.0";
+/**
+ * The response header that names who imposed a delayed retry.
+ *
+ * It is a header rather than an envelope field on purpose. Contract-set 2.0.0 error envelopes are
+ * closed schemas, and this repository's compatibility rule treats *any* added output property —
+ * required or optional — as breaking, because the generated clients parse closed-world and would
+ * reject a wider body. A header carries the same machine-readable fact additively, so a client
+ * pinned to 1.13.52 keeps working byte-for-byte while a client that wants the distinction can read
+ * it today. Moving it into the envelope belongs to the next contract major.
+ *
+ * Why the distinction matters at all: before Task 18.2 an OxChannels policy limit and a provider
+ * throttle both arrived as a bare `RATE_LIMITED`, and the backend answered every non-public 429
+ * with a hardcoded sixty seconds. Retrying at an interval we invented, inside a window somebody
+ * else set, is how a connected account gets suspended.
+ *
+ * The operator-facing surfaces publish the same distinction in full: `GET /privacy/limits` returns
+ * our thresholds and the provider's observed limits as two separate lists, and
+ * `GET /privacy/limit-decisions` records every judgement with its authority.
+ */
+export declare const LIMIT_AUTHORITY_HEADER: "oxchannels-limit-authority";
+export declare const LIMIT_AUTHORITY_HEADER_VALUES: readonly ["OXCHANNELS", "PROVIDER"];
+export type LimitAuthorityHeaderValue = (typeof LIMIT_AUTHORITY_HEADER_VALUES)[number];
+export declare const ACTIVE_API_ERROR_CODES: readonly ["INVALID_REQUEST", "AUTHENTICATION_REQUIRED", "FORBIDDEN", "NOT_FOUND", "IDEMPOTENCY_CONFLICT", "RATE_LIMITED", "INTERNAL_SAFE_FAILURE"];
+export declare const ACTIVE_API_ERROR_CODES_V2: readonly ["INVALID_REQUEST", "AUTHENTICATION_REQUIRED", "FORBIDDEN", "NOT_FOUND", "IDEMPOTENCY_CONFLICT", "RATE_LIMITED", "INTERNAL_SAFE_FAILURE", "CONFLICT"];
+export declare const COLLABORATION_CONFLICT_CODES: readonly ["DUPLICATE_INVITATION", "LAST_OWNER", "ROLE_CEILING", "SELF_MUTATION_REQUIRES_TRANSFER", "STALE_ACCESS_GENERATION", "STALE_ACCOUNT_GROUP", "STALE_INVITATION", "STALE_MEMBERSHIP"];
+export declare const RESERVED_API_ERROR_CODES: readonly ["SCHEMA_UNSUPPORTED", "STALE_CAPABILITY", "UNSUPPORTED_ACTION", "CONNECTION_REQUIRED", "PROVIDER_REAUTH_REQUIRED", "PROVIDER_REVIEW_REQUIRED", "PROVIDER_PERMISSION_DENIED", "PROVIDER_REJECTED", "DEPENDENCY_UNAVAILABLE", "UNKNOWN_EFFECT"];
+export type ActiveApiErrorCode = (typeof ACTIVE_API_ERROR_CODES)[number];
+export type ActiveApiErrorCodeV2 = (typeof ACTIVE_API_ERROR_CODES_V2)[number];
+export type CollaborationConflictCode = (typeof COLLABORATION_CONFLICT_CODES)[number];
+export type ReservedApiErrorCode = (typeof RESERVED_API_ERROR_CODES)[number];
+export type ApiErrorCode = ActiveApiErrorCodeV2 | ReservedApiErrorCode;
+export type ApiErrorTaxonomyStatus = 'ACTIVE' | 'RESERVED';
+export type ApiErrorCategory = 'VALIDATION' | 'AUTHENTICATION' | 'AUTHORIZATION' | 'RESOURCE' | 'CONFLICT' | 'RATE_LIMIT' | 'CAPABILITY' | 'PROVIDER' | 'DEPENDENCY' | 'INTERNAL';
+export type ApiErrorRetry = 'NONE' | 'AFTER_DELAY' | 'REFRESH_AUTH' | 'POLL' | 'MANUAL_REVIEW';
+export type ApiErrorEffect = 'NOT_APPLIED' | 'NO_EFFECT_CLAIM' | 'UNKNOWN';
+export interface ApiErrorTaxonomyEntry {
+    readonly code: ApiErrorCode;
+    readonly status: ApiErrorTaxonomyStatus;
+    readonly category: ApiErrorCategory;
+    readonly defaultHttpStatus: number;
+    readonly retry: ApiErrorRetry;
+    readonly effect: ApiErrorEffect;
+}
+export declare const API_ERROR_TAXONOMY: Readonly<Record<ApiErrorCode, Readonly<ApiErrorTaxonomyEntry>>>;
+export type ContractJsonSchema = Readonly<Record<string, unknown>>;
+export declare const API_ERROR_TAXONOMY_ENTRY_JSON_SCHEMA: ContractJsonSchema;
+export declare const ERROR_ENVELOPE_V1_JSON_SCHEMA: ContractJsonSchema;
+export declare const ERROR_ENVELOPE_V2_JSON_SCHEMA: ContractJsonSchema;
+export declare const API_ERROR_TAXONOMY_ENTRY_OPENAPI_SCHEMA: Readonly<Record<string, unknown>>;
+export declare const ERROR_ENVELOPE_V1_OPENAPI_SCHEMA: Readonly<Record<string, unknown>>;
+export declare const ERROR_ENVELOPE_V2_OPENAPI_SCHEMA: Readonly<Record<string, unknown>>;
+export declare const ERROR_ENVELOPE_V2_VARIANT_OPENAPI_SCHEMAS: Readonly<Record<ActiveApiErrorCodeV2, ContractJsonSchema>>;
+export interface ApiErrorEnvelopeV1 {
+    readonly version: 'v1';
+    readonly code: ActiveApiErrorCode;
+    readonly message: string;
+    readonly traceId: string;
+    readonly retryable: boolean;
+}
+export interface ApiErrorEnvelopeV2 {
+    readonly schemaVersion: typeof PARITY_CONTRACT_SET_VERSION;
+    readonly code: ActiveApiErrorCodeV2;
+    readonly category: ApiErrorCategory;
+    readonly message: string;
+    readonly traceId: string;
+    readonly correlationId: string;
+    readonly retryable: boolean;
+    readonly effectEvidence: 'NOT_APPLIED' | 'UNKNOWN' | null;
+    readonly retryAfterSeconds?: number;
+    readonly violations?: readonly Readonly<ApiErrorViolation>[];
+}
+export interface ApiErrorViolation {
+    readonly path: string;
+    readonly code: string;
+}
+export interface CollaborationConflictViolation extends ApiErrorViolation {
+    readonly path: 'collaboration';
+    readonly code: CollaborationConflictCode;
+}
+export declare function isCollaborationConflictCode(value: unknown): value is CollaborationConflictCode;
+export declare function parseApiErrorEnvelopeV1(value: unknown): Readonly<ApiErrorEnvelopeV1>;
+export declare function parseApiErrorEnvelopeV2(value: unknown): Readonly<ApiErrorEnvelopeV2>;