@xkova/sdk 0.1.0-alpha.1

package/dist/resources/account-holders.d.ts

@@ -0,0 +1,295 @@
+import { Resource, type ReqBody, type Query } from './base.js';
+import type { XKOVAClient, XKOVAMutationOptions, XKOVARequestControl } from '../client.js';
+/** Trusted BFF context for operations scoped to the current member. */
+export interface XKOVAMemberSessionContext {
+    /** Opaque XKOVA session UUID stored by the customer BFF. */
+    memberSessionId: string;
+    /** Non-secret application registration identifier stored with the session by the BFF. */
+    memberAuthPublishableKey: string;
+}
+export declare class AccountHoldersResource extends Resource {
+    private readonly storageFetch;
+    constructor(client: XKOVAClient, storageFetch?: typeof fetch);
+    list(query?: Query<'listAccountHolders'>): Promise<{
+        data: unknown[];
+        next_cursor: string | null;
+        has_more: boolean;
+    } & {
+        data?: import("../generated/types.js").components["schemas"]["AccountHolder"][];
+    }>;
+    create(body: ReqBody<'createAccountHolder'>, opts?: XKOVAMutationOptions): Promise<{
+        id: import("../generated/types.js").components["schemas"]["AccountHolderId"];
+        tenant_id?: string;
+        state: "active" | "held" | "closed" | "closed_uncooperative" | "provisioning_failed";
+        state_reason?: string | null;
+        state_changed_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        tier: "tier_1" | "tier_2";
+        tier_2_uplift_status?: "not_requested" | "pending" | "passed" | "failed";
+        first_use_completed: boolean;
+        cip_payload?: {
+            name_hash?: string;
+            dob_hash?: string;
+            id_hash?: string;
+            address_hash?: string;
+        } | null;
+        cip_accepted_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        merchant_role_state?: "none" | "pending_review" | "approved" | "rejected" | "revoked";
+        auto_save_contacts?: boolean;
+        created_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        email?: string | null;
+        first_name?: string | null;
+        last_name?: string | null;
+        phone?: string | null;
+        avatar_url?: string | null;
+    }>;
+    retrieve(id: string, query?: Query<'getAccountHolder'>): Promise<{
+        id: import("../generated/types.js").components["schemas"]["AccountHolderId"];
+        tenant_id?: string;
+        state: "active" | "held" | "closed" | "closed_uncooperative" | "provisioning_failed";
+        state_reason?: string | null;
+        state_changed_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        tier: "tier_1" | "tier_2";
+        tier_2_uplift_status?: "not_requested" | "pending" | "passed" | "failed";
+        first_use_completed: boolean;
+        cip_payload?: {
+            name_hash?: string;
+            dob_hash?: string;
+            id_hash?: string;
+            address_hash?: string;
+        } | null;
+        cip_accepted_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        merchant_role_state?: "none" | "pending_review" | "approved" | "rejected" | "revoked";
+        auto_save_contacts?: boolean;
+        created_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        email?: string | null;
+        first_name?: string | null;
+        last_name?: string | null;
+        phone?: string | null;
+        avatar_url?: string | null;
+    }>;
+    update(id: string, body: ReqBody<'updateAccountHolder'>, opts?: XKOVAMutationOptions): Promise<{
+        id: import("../generated/types.js").components["schemas"]["AccountHolderId"];
+        tenant_id?: string;
+        state: "active" | "held" | "closed" | "closed_uncooperative" | "provisioning_failed";
+        state_reason?: string | null;
+        state_changed_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        tier: "tier_1" | "tier_2";
+        tier_2_uplift_status?: "not_requested" | "pending" | "passed" | "failed";
+        first_use_completed: boolean;
+        cip_payload?: {
+            name_hash?: string;
+            dob_hash?: string;
+            id_hash?: string;
+            address_hash?: string;
+        } | null;
+        cip_accepted_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        merchant_role_state?: "none" | "pending_review" | "approved" | "rejected" | "revoked";
+        auto_save_contacts?: boolean;
+        created_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        email?: string | null;
+        first_name?: string | null;
+        last_name?: string | null;
+        phone?: string | null;
+        avatar_url?: string | null;
+    }>;
+    history(id: string, query?: Query<'listAccountHolderHistory'>): Promise<{
+        data: import("../generated/types.js").components["schemas"]["WalletTransactionSummary"][];
+        next_cursor?: string | null;
+        has_more: boolean;
+    }>;
+    selfVerification(context: XKOVAMemberSessionContext, control?: XKOVARequestControl): Promise<{
+        required: boolean;
+        status: string;
+        verified_via: string | null;
+        verified_at: string | null;
+        verification_expires_at: string | null;
+        required_kinds: ("kyc" | "kyb")[];
+        sessions: {
+            kind: "kyc" | "kyb";
+            status: string;
+            vendor: string | null;
+            vendor_detail_url: string | null;
+            initiated_at: string | null;
+            completed_at: string | null;
+            expires_at: string | null;
+        }[];
+        verification_url: string | null;
+    }>;
+    selfBalance(context: XKOVAMemberSessionContext, control?: XKOVARequestControl): Promise<{
+        balances: import("../generated/types.js").components["schemas"]["AccountHolderSelfBalanceEntry"][];
+    }>;
+    listSelfWallets(context: XKOVAMemberSessionContext, control?: XKOVARequestControl): Promise<{
+        data: import("../generated/types.js").components["schemas"]["Wallet"][];
+    }>;
+    selfWalletReadiness(context: XKOVAMemberSessionContext, control?: XKOVARequestControl): Promise<{
+        status: "not_registered" | "provisioning" | "ready";
+        wallets: import("../generated/types.js").components["schemas"]["Wallet"][];
+    }>;
+    ensureSelfWalletProvisioning(context: XKOVAMemberSessionContext, opts?: XKOVAMutationOptions): Promise<{
+        status: "pending" | "processing" | "reconciling" | "retry" | "ready" | "paused" | "manual_review" | "cancelled";
+    }>;
+    selfBankBalance(context: XKOVAMemberSessionContext, control?: XKOVARequestControl): Promise<{
+        currency: "USD";
+        available_balance: import("../generated/types.js").components["schemas"]["Money"];
+        current_balance: import("../generated/types.js").components["schemas"]["Money"];
+        as_of: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+    }>;
+    selfSandboxBankingContext(context: XKOVAMemberSessionContext, control?: XKOVARequestControl): Promise<{
+        account_holder_id: import("../generated/types.js").components["schemas"]["AccountHolderId"];
+        savings_bank_account_id: string;
+        checking_bank_account_id: string;
+        pool_bank_account_id: string;
+        settlement_bank_account_id: string;
+        destination_account: import("../generated/types.js").components["schemas"]["CuPayoutAccountRef"];
+    }>;
+    /** Advisory, uncached setup facts from the existing exact-session read. */
+    selfActionReadiness(context: XKOVAMemberSessionContext & {
+        accountHolderId: string;
+    }, control?: XKOVARequestControl): Promise<{
+        authorization_method: "hosted_passkey" | "external_oidc";
+        setup_status: "passkey_required" | "recovery_acknowledgement_required" | "recovery_required" | "ready" | "externally_managed";
+        action_authorization_enabled: boolean;
+        requires_fresh_proof: true;
+        provider_status: "not_checked";
+    }>;
+    listSelfBankTransactions(context: XKOVAMemberSessionContext, query?: Query<'listAccountHolderSelfBankTransactions'>, control?: XKOVARequestControl): Promise<{
+        data: {
+            transfer_ref: string;
+            amount: string;
+            currency: string;
+            status: "pending" | "posted" | "reversed" | "rejected";
+            from_account: "savings" | "checking" | "other";
+            to_account: "savings" | "checking" | "other";
+            memo?: string | null;
+            occurred_at: string;
+        }[];
+    }>;
+    createSelfBankTransfer(context: XKOVAMemberSessionContext, body: ReqBody<'createAccountHolderSelfBankTransfer'>, opts?: XKOVAMutationOptions): Promise<{
+        transfer_ref: string;
+        status: "pending" | "posted" | "reversed" | "rejected";
+        as_of: string;
+    }>;
+    selfCheckingBalance(context: XKOVAMemberSessionContext, control?: XKOVARequestControl): Promise<{
+        currency: "USD";
+        available_balance: import("../generated/types.js").components["schemas"]["Money"];
+        current_balance: import("../generated/types.js").components["schemas"]["Money"];
+        as_of: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+    }>;
+    selfConsentState(context: XKOVAMemberSessionContext, control?: XKOVARequestControl): Promise<{
+        account_holder_id: import("../generated/types.js").components["schemas"]["AccountHolderId"];
+        current_policies: import("../generated/types.js").components["schemas"]["CurrentPolicy"][];
+        accepted: import("../generated/types.js").components["schemas"]["Consent"][];
+        missing_consents: import("../generated/types.js").components["schemas"]["MissingConsent"][];
+        consents_current: boolean;
+        first_use_completed: boolean;
+    }>;
+    acceptSelfConsents(context: XKOVAMemberSessionContext, body: ReqBody<'acceptAccountHolderConsents'>, opts?: XKOVAMutationOptions): Promise<{
+        account_holder_id: import("../generated/types.js").components["schemas"]["AccountHolderId"];
+        current_policies: import("../generated/types.js").components["schemas"]["CurrentPolicy"][];
+        accepted: import("../generated/types.js").components["schemas"]["Consent"][];
+        missing_consents: import("../generated/types.js").components["schemas"]["MissingConsent"][];
+        consents_current: boolean;
+        first_use_completed: boolean;
+    }>;
+    requestSelfDataExport(context: XKOVAMemberSessionContext, opts?: XKOVAMutationOptions): Promise<{
+        id: import("../generated/types.js").components["schemas"]["DataExportId"];
+        account_holder_id: import("../generated/types.js").components["schemas"]["AccountHolderId"];
+        state: "queued" | "processing" | "ready" | "expired" | "failed";
+        signed_url: string | null;
+        url_expires_at: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        requested_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        started_at: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        completed_at: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        failure_reason: string | null;
+    }>;
+    selfDataExport(context: XKOVAMemberSessionContext, id: string, control?: XKOVARequestControl): Promise<{
+        id: import("../generated/types.js").components["schemas"]["DataExportId"];
+        account_holder_id: import("../generated/types.js").components["schemas"]["AccountHolderId"];
+        state: "queued" | "processing" | "ready" | "expired" | "failed";
+        signed_url: string | null;
+        url_expires_at: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        requested_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        started_at: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        completed_at: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        failure_reason: string | null;
+    }>;
+    listSelfTransactions(context: XKOVAMemberSessionContext, query?: Query<'listAccountHolderSelfTransactions'>, control?: XKOVARequestControl): Promise<{
+        data: import("../generated/types.js").components["schemas"]["AccountHolderSelfTransaction"][];
+        next_cursor: string | null;
+        has_more: boolean;
+    }>;
+    /**
+     * Server-side avatar upload using the platform's presign/upload/confirm
+     * contract. Only image bytes go to object storage. API bearer, signatures,
+     * member context and cookies never follow the presigned URL or a redirect.
+     */
+    uploadAvatar(id: string, image: Blob, control?: XKOVARequestControl): Promise<{
+        url: string | null;
+    }>;
+    avatarUrl(id: string): Promise<{
+        url: string | null;
+    }>;
+    deleteAvatar(id: string, opts?: XKOVAMutationOptions): Promise<{
+        id: import("../generated/types.js").components["schemas"]["AccountHolderId"];
+        tenant_id?: string;
+        state: "active" | "held" | "closed" | "closed_uncooperative" | "provisioning_failed";
+        state_reason?: string | null;
+        state_changed_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        tier: "tier_1" | "tier_2";
+        tier_2_uplift_status?: "not_requested" | "pending" | "passed" | "failed";
+        first_use_completed: boolean;
+        cip_payload?: {
+            name_hash?: string;
+            dob_hash?: string;
+            id_hash?: string;
+            address_hash?: string;
+        } | null;
+        cip_accepted_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        merchant_role_state?: "none" | "pending_review" | "approved" | "rejected" | "revoked";
+        auto_save_contacts?: boolean;
+        created_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        email?: string | null;
+        first_name?: string | null;
+        last_name?: string | null;
+        phone?: string | null;
+        avatar_url?: string | null;
+    }>;
+    confirmAvatar(id: string, body: ReqBody<'confirmAccountHolderAvatar'>, opts?: XKOVAMutationOptions): Promise<{
+        id: import("../generated/types.js").components["schemas"]["AccountHolderId"];
+        tenant_id?: string;
+        state: "active" | "held" | "closed" | "closed_uncooperative" | "provisioning_failed";
+        state_reason?: string | null;
+        state_changed_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        tier: "tier_1" | "tier_2";
+        tier_2_uplift_status?: "not_requested" | "pending" | "passed" | "failed";
+        first_use_completed: boolean;
+        cip_payload?: {
+            name_hash?: string;
+            dob_hash?: string;
+            id_hash?: string;
+            address_hash?: string;
+        } | null;
+        cip_accepted_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"] | null;
+        merchant_role_state?: "none" | "pending_review" | "approved" | "rejected" | "revoked";
+        auto_save_contacts?: boolean;
+        created_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        updated_at?: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+        email?: string | null;
+        first_name?: string | null;
+        last_name?: string | null;
+        phone?: string | null;
+        avatar_url?: string | null;
+    }>;
+    presignAvatarUpload(id: string, body: ReqBody<'presignAccountHolderAvatarUpload'>, opts?: XKOVAMutationOptions): Promise<{
+        upload_url: string;
+        object_key: string;
+        expires_at: import("../generated/types.js").components["schemas"]["TimestampUtc"];
+    }>;
+    listWallets(id: string): Promise<{
+        data: import("../generated/types.js").components["schemas"]["Wallet"][];
+    }>;
+}

package/dist/resources/account-holders.js

@@ -0,0 +1,166 @@
+import { Resource } from './base.js';
+import { XKOVAUploadError } from '../errors.js';
+function memberSessionHeaders(context) {
+    return {
+        'X-Member-Session-Id': context.memberSessionId,
+        'X-XKOVA-Publishable-Key': context.memberAuthPublishableKey,
+    };
+}
+export class AccountHoldersResource extends Resource {
+    storageFetch;
+    constructor(client, storageFetch = fetch) {
+        super(client);
+        this.storageFetch = storageFetch;
+    }
+    list(query = {}) {
+        return this.getJson('/account-holders', query);
+    }
+    create(body, opts) {
+        return this.postJson('/account-holders', body, opts);
+    }
+    retrieve(id, query = {}) {
+        return this.getJson(`/account-holders/${this.enc(id)}`, query);
+    }
+    update(id, body, opts) {
+        return this.patchJson(`/account-holders/${this.enc(id)}`, body, opts);
+    }
+    history(id, query = {}) {
+        return this.getJson(`/account-holders/${this.enc(id)}/history`, query);
+    }
+    selfVerification(context, control) {
+        return this.getJson('/account-holders/self/verification', undefined, control, memberSessionHeaders(context));
+    }
+    selfBalance(context, control) {
+        return this.getJson('/account-holders/self/balance', undefined, control, memberSessionHeaders(context));
+    }
+    listSelfWallets(context, control) {
+        return this.getJson('/account-holders/self/wallets', undefined, control, memberSessionHeaders(context));
+    }
+    selfWalletReadiness(context, control) {
+        return this.getJson('/account-holders/self/wallet-readiness', undefined, control, memberSessionHeaders(context));
+    }
+    ensureSelfWalletProvisioning(context, opts) {
+        return this.postJson('/account-holders/self/wallet-provision', undefined, opts, undefined, memberSessionHeaders(context));
+    }
+    selfBankBalance(context, control) {
+        return this.getJson('/account-holders/self/bank-balance', undefined, control, memberSessionHeaders(context));
+    }
+    selfSandboxBankingContext(context, control) {
+        return this.getJson('/account-holders/self/sandbox-banking-context', undefined, control, memberSessionHeaders(context));
+    }
+    /** Advisory, uncached setup facts from the existing exact-session read. */
+    async selfActionReadiness(context, control) {
+        const status = await this.getJson('/member-auth/session', undefined, control, memberSessionHeaders(context));
+        if (status.session_id !== context.memberSessionId ||
+            status.account_holder_id !== context.accountHolderId) {
+            throw new Error('Member readiness returned a different session or account holder');
+        }
+        const readiness = status.action_readiness;
+        if (!readiness ||
+            !['hosted_passkey', 'external_oidc'].includes(readiness.authorization_method) ||
+            ![
+                'passkey_required',
+                'recovery_acknowledgement_required',
+                'recovery_required',
+                'ready',
+                'externally_managed',
+            ].includes(readiness.setup_status) ||
+            typeof readiness.action_authorization_enabled !== 'boolean' ||
+            readiness.requires_fresh_proof !== true ||
+            readiness.provider_status !== 'not_checked') {
+            throw new Error('Member action readiness response is invalid');
+        }
+        return readiness;
+    }
+    listSelfBankTransactions(context, query = {}, control) {
+        return this.getJson('/account-holders/self/bank-transactions', query, control, memberSessionHeaders(context));
+    }
+    createSelfBankTransfer(context, body, opts) {
+        return this.postJson('/account-holders/self/bank-transfers', body, opts, undefined, memberSessionHeaders(context));
+    }
+    selfCheckingBalance(context, control) {
+        return this.getJson('/account-holders/self/checking-balance', undefined, control, memberSessionHeaders(context));
+    }
+    selfConsentState(context, control) {
+        return this.getJson('/account-holders/self/consents', undefined, control, memberSessionHeaders(context));
+    }
+    acceptSelfConsents(context, body, opts) {
+        return this.postJson('/account-holders/self/consents', body, opts, undefined, memberSessionHeaders(context));
+    }
+    requestSelfDataExport(context, opts) {
+        return this.postJson('/account-holders/self/data-exports', undefined, opts, undefined, memberSessionHeaders(context));
+    }
+    selfDataExport(context, id, control) {
+        return this.getJson(`/account-holders/self/data-exports/${this.enc(id)}`, undefined, control, memberSessionHeaders(context));
+    }
+    listSelfTransactions(context, query = {}, control) {
+        return this.getJson('/account-holders/self/transactions', query, control, memberSessionHeaders(context));
+    }
+    /**
+     * Server-side avatar upload using the platform's presign/upload/confirm
+     * contract. Only image bytes go to object storage. API bearer, signatures,
+     * member context and cookies never follow the presigned URL or a redirect.
+     */
+    async uploadAvatar(id, image, control = {}) {
+        if (!['image/png', 'image/jpeg', 'image/webp', 'image/gif'].includes(image.type) ||
+            image.size === 0 ||
+            image.size > 5 * 1024 * 1024) {
+            throw new TypeError('Avatar must be a PNG, JPEG, WebP, or GIF image of at most 5 MiB');
+        }
+        const upload = await this.presignAvatarUpload(id, {
+            content_type: image.type,
+            content_length: image.size,
+        }, control);
+        const target = new URL(upload.upload_url);
+        if (target.username ||
+            target.password ||
+            target.hash ||
+            (target.protocol !== 'https:' &&
+                !(target.protocol === 'http:' && target.hostname === 'localhost')) ||
+            !Number.isFinite(Date.parse(upload.expires_at)) ||
+            Date.parse(upload.expires_at) <= Date.now()) {
+            throw new XKOVAUploadError('The avatar upload capability is invalid or expired');
+        }
+        let response;
+        try {
+            response = await this.storageFetch(target, {
+                method: 'PUT',
+                body: image,
+                headers: {
+                    'content-type': image.type,
+                    'content-length': String(image.size),
+                },
+                credentials: 'omit',
+                redirect: 'error',
+                referrerPolicy: 'no-referrer',
+                cache: 'no-store',
+                signal: control.signal
+                    ? AbortSignal.any([control.signal, AbortSignal.timeout(30_000)])
+                    : AbortSignal.timeout(30_000),
+            });
+        }
+        catch {
+            // Never attach provider errors containing the signed URL to a public error.
+            throw new XKOVAUploadError('Object storage did not accept the avatar upload');
+        }
+        if (!response.ok)
+            throw new XKOVAUploadError('Object storage rejected the avatar upload', response.status);
+        await this.confirmAvatar(id, { object_key: upload.object_key }, control);
+        return this.avatarUrl(id);
+    }
+    avatarUrl(id) {
+        return this.getJson(`/account-holders/${this.enc(id)}/avatar`);
+    }
+    deleteAvatar(id, opts) {
+        return this.deleteJson(`/account-holders/${this.enc(id)}/avatar`, opts);
+    }
+    confirmAvatar(id, body, opts) {
+        return this.postJson(`/account-holders/${this.enc(id)}/avatar/confirm`, body, opts);
+    }
+    presignAvatarUpload(id, body, opts) {
+        return this.postJson(`/account-holders/${this.enc(id)}/avatar/upload-url`, body, opts);
+    }
+    listWallets(id) {
+        return this.getJson(`/account-holders/${this.enc(id)}/wallets`);
+    }
+}

package/dist/resources/base.d.ts

@@ -0,0 +1,47 @@
+import type { operations } from '../generated/types.js';
+import type { XKOVAClient, XKOVAMutationOptions, XKOVARequestControl } from '../client.js';
+export type OpId = keyof operations;
+type SuccessStatus = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+type ResponseBody<T> = T extends {
+    content: infer Content;
+} ? Content extends {
+    'application/json': infer Body;
+} ? Body : Content extends {
+    'image/svg+xml': unknown;
+} ? string : Content extends {
+    'text/csv': unknown;
+} ? string : unknown : void;
+export type Ok<Op extends OpId> = operations[Op] extends {
+    responses: infer Responses;
+} ? ResponseBody<Responses[keyof Responses & SuccessStatus]> : never;
+export type ReqBody<Op extends OpId> = operations[Op] extends {
+    requestBody: {
+        content: {
+            'application/json': infer Body;
+        };
+    };
+} ? Body : operations[Op] extends {
+    requestBody?: {
+        content: {
+            'application/json': infer Body;
+        };
+    };
+} ? Body : never;
+export type Query<Op extends OpId> = operations[Op] extends {
+    parameters: {
+        query?: infer Params;
+    };
+} ? NonNullable<Params> : Record<string, never>;
+type QueryRecord = Record<string, string | number | boolean | null | undefined | readonly string[]>;
+export declare abstract class Resource {
+    protected readonly client: XKOVAClient;
+    constructor(client: XKOVAClient);
+    protected getJson<Op extends OpId>(path: `/${string}`, query?: QueryRecord, control?: XKOVARequestControl, headers?: Record<string, string>): Promise<Ok<Op>>;
+    protected getText<Op extends OpId>(path: `/${string}`, query?: QueryRecord, control?: XKOVARequestControl, accept?: string): Promise<Ok<Op>>;
+    protected postJson<Op extends OpId, Body = ReqBody<Op>>(path: `/${string}`, body?: Body, opts?: XKOVAMutationOptions, query?: QueryRecord, headers?: Record<string, string>): Promise<Ok<Op>>;
+    protected putJson<Op extends OpId, Body = ReqBody<Op>>(path: `/${string}`, body: Body, opts?: XKOVAMutationOptions, query?: QueryRecord, headers?: Record<string, string>): Promise<Ok<Op>>;
+    protected patchJson<Op extends OpId, Body = ReqBody<Op>>(path: `/${string}`, body: Body, opts?: XKOVAMutationOptions, query?: QueryRecord, headers?: Record<string, string>): Promise<Ok<Op>>;
+    protected deleteJson<Op extends OpId>(path: `/${string}`, opts?: XKOVAMutationOptions, query?: QueryRecord, headers?: Record<string, string>): Promise<Ok<Op>>;
+    protected enc(value: string): string;
+}
+export {};

package/dist/resources/base.js

@@ -0,0 +1,25 @@
+export class Resource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    getJson(path, query, control = {}, headers) {
+        return this.client.requestJson({ method: 'GET', path, ...(query !== undefined && { query }), ...(headers !== undefined && { headers }), ...(control.signal !== undefined && { signal: control.signal }) });
+    }
+    getText(path, query, control = {}, accept = 'text/plain, */*') {
+        return this.client.requestText({ method: 'GET', path, accept, ...(query !== undefined && { query }), ...(control.signal !== undefined && { signal: control.signal }) });
+    }
+    postJson(path, body, opts = {}, query, headers) {
+        return this.client.requestJson({ method: 'POST', path, ...(body !== undefined && { body }), ...(query !== undefined && { query }), ...(headers !== undefined && { headers }), ...(opts.idempotencyKey !== undefined && { idempotencyKey: opts.idempotencyKey }), ...(opts.signal !== undefined && { signal: opts.signal }) });
+    }
+    putJson(path, body, opts = {}, query, headers) {
+        return this.client.requestJson({ method: 'PUT', path, body, ...(query !== undefined && { query }), ...(headers !== undefined && { headers }), ...(opts.idempotencyKey !== undefined && { idempotencyKey: opts.idempotencyKey }), ...(opts.signal !== undefined && { signal: opts.signal }) });
+    }
+    patchJson(path, body, opts = {}, query, headers) {
+        return this.client.requestJson({ method: 'PATCH', path, body, ...(query !== undefined && { query }), ...(headers !== undefined && { headers }), ...(opts.idempotencyKey !== undefined && { idempotencyKey: opts.idempotencyKey }), ...(opts.signal !== undefined && { signal: opts.signal }) });
+    }
+    deleteJson(path, opts = {}, query, headers) {
+        return this.client.requestJson({ method: 'DELETE', path, ...(query !== undefined && { query }), ...(headers !== undefined && { headers }), ...(opts.idempotencyKey !== undefined && { idempotencyKey: opts.idempotencyKey }), ...(opts.signal !== undefined && { signal: opts.signal }) });
+    }
+    enc(value) { return encodeURIComponent(value); }
+}