@openora/core 0.4.0

package/dist/compliance/adapters/hmac-kyc-webhook-verifier.js

@@ -0,0 +1,29 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+/**
+ * Default KYC-webhook verifier: recomputes an HMAC-SHA256 of the raw request body
+ * keyed by the configured secret and constant-time compares the hex digest against
+ * the signature header (a leading `sha256=` is tolerated). Fails closed when the
+ * secret is unset, the signature is absent, or the body was not captured.
+ */
+export class HmacKycWebhookVerifier {
+    secret;
+    constructor(secret) {
+        this.secret = secret;
+    }
+    verify(rawBody, signature) {
+        if (!this.secret || !signature) {
+            return false;
+        }
+        const provided = signature.startsWith('sha256=')
+            ? signature.slice('sha256='.length)
+            : signature;
+        const expected = createHmac('sha256', this.secret).update(rawBody, 'utf8').digest('hex');
+        const expectedBuf = Buffer.from(expected, 'utf8');
+        const providedBuf = Buffer.from(provided, 'utf8');
+        if (expectedBuf.length !== providedBuf.length) {
+            return false;
+        }
+        return timingSafeEqual(expectedBuf, providedBuf);
+    }
+}
+//# sourceMappingURL=hmac-kyc-webhook-verifier.js.map

package/dist/compliance/adapters/hmac-kyc-webhook-verifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmac-kyc-webhook-verifier.js","sourceRoot":"","sources":["../../../src/compliance/adapters/hmac-kyc-webhook-verifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAG1D;;;;;GAKG;AACH,MAAM,OAAO,sBAAsB;IACJ;IAA7B,YAA6B,MAA0B;QAA1B,WAAM,GAAN,MAAM,CAAoB;IAAG,CAAC;IAE3D,MAAM,CAAC,OAAe,EAAE,SAAwB;QAC9C,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;YAC/B,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,QAAQ,GAAG,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC;YAC9C,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC;YACnC,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACzF,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAClD,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAClD,IAAI,WAAW,CAAC,MAAM,KAAK,WAAW,CAAC,MAAM,EAAE,CAAC;YAC9C,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,eAAe,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IACnD,CAAC;CACF"}

package/dist/compliance/assert.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Runtime assertion that every sealed service the platform actually implements
+ * (`IMPLEMENTED_SEALED_TOKENS`) is bound in the assembled DI container. Operators
+ * run this in their CI suite against their assembled app to catch a
+ * misconfigured deployment where a regulator-mandated service's owning module
+ * was never loaded (eg the audit module disabled, silently dropping every
+ * audit write).
+ *
+ * A sealed token can only ever be bound once, by its owning module, via
+ * `ctx.provideSealed()` - `ctx.provide()` rejects any sealed token outright and
+ * `provideSealed()` itself refuses a second bind (see module-registry.ts). So a
+ * bound sealed token is always the owner's canonical implementation, never a
+ * plugin override; this check exists to catch an ABSENT binding, not a hijacked
+ * one - the hijack path is already closed at bind time for every deployment.
+ *
+ * The argument shape is intentionally minimal - any container exposing a
+ * boolean `has(token)` works. `@openora/core/server` `Container.has(token)` satisfies it.
+ *
+ * Throws listing every sealed service that isn't bound.
+ */
+export type SealedContainerView = {
+    has(token: symbol): boolean;
+};
+export declare function assertSealedServicesBound(container: SealedContainerView): void;
+//# sourceMappingURL=assert.d.ts.map

package/dist/compliance/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/compliance/assert.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;CAC7B,CAAC;AAEF,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,mBAAmB,GAAG,IAAI,CAc9E"}

package/dist/compliance/assert.js

@@ -0,0 +1,15 @@
+import { IMPLEMENTED_SEALED_TOKENS } from './sealed.js';
+export function assertSealedServicesBound(container) {
+    const missing = [];
+    for (const token of IMPLEMENTED_SEALED_TOKENS) {
+        if (!container.has(token)) {
+            missing.push(token.description ?? '(unnamed)');
+        }
+    }
+    if (missing.length > 0) {
+        throw new Error(`[compliance-invariants] sealed services must be bound by their owning module:\n` +
+            missing.map((v) => `  - ${v}`).join('\n') +
+            `\nSee @openora/core/compliance/sealed.ts for the regulatory citations.`);
+    }
+}
+//# sourceMappingURL=assert.js.map

package/dist/compliance/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.js","sourceRoot":"","sources":["../../src/compliance/assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AA0BxD,MAAM,UAAU,yBAAyB,CAAC,SAA8B;IACtE,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,KAAK,MAAM,KAAK,IAAI,yBAAyB,EAAE,CAAC;QAC9C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,IAAI,WAAW,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;IACD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CACb,iFAAiF;YAC/E,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;YACzC,wEAAwE,CAC3E,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/compliance/contract/enums.d.ts

@@ -0,0 +1,3 @@
+export declare const KYC_DOCUMENT_TYPES: readonly ["passport", "drivers_license", "national_id"];
+export declare const KYC_TRIGGERED_BY: readonly ["submission", "reverify_threshold", "manual"];
+//# sourceMappingURL=enums.d.ts.map

package/dist/compliance/contract/enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../../src/compliance/contract/enums.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,yDAA0D,CAAC;AAC1F,eAAO,MAAM,gBAAgB,yDAA0D,CAAC"}

package/dist/compliance/contract/enums.js

@@ -0,0 +1,3 @@
+export const KYC_DOCUMENT_TYPES = ['passport', 'drivers_license', 'national_id'];
+export const KYC_TRIGGERED_BY = ['submission', 'reverify_threshold', 'manual'];
+//# sourceMappingURL=enums.js.map

package/dist/compliance/contract/enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../../src/compliance/contract/enums.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,UAAU,EAAE,iBAAiB,EAAE,aAAa,CAAU,CAAC;AAC1F,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,YAAY,EAAE,oBAAoB,EAAE,QAAQ,CAAU,CAAC"}

package/dist/compliance/contract/index.d.ts

@@ -0,0 +1,582 @@
+import * as z from 'zod';
+export declare const KycDocumentTypeSchema: z.ZodEnum<{
+    passport: "passport";
+    drivers_license: "drivers_license";
+    national_id: "national_id";
+}>;
+export declare const KycTriggeredBySchema: z.ZodEnum<{
+    manual: "manual";
+    submission: "submission";
+    reverify_threshold: "reverify_threshold";
+}>;
+export declare const KycDocumentSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        passport: "passport";
+        drivers_license: "drivers_license";
+        national_id: "national_id";
+    }>;
+    frontUrl: z.ZodString;
+    backUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const KycVerificationSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    userId: z.ZodUUID;
+    provider: z.ZodString;
+    referenceId: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        not_started: "not_started";
+        verified: "verified";
+        rejected: "rejected";
+        resubmission_requested: "resubmission_requested";
+        manually_overridden: "manually_overridden";
+    }>;
+    documentTypes: z.ZodArray<z.ZodEnum<{
+        passport: "passport";
+        drivers_license: "drivers_license";
+        national_id: "national_id";
+    }>>;
+    decisionReason: z.ZodNullable<z.ZodString>;
+    triggeredBy: z.ZodEnum<{
+        manual: "manual";
+        submission: "submission";
+        reverify_threshold: "reverify_threshold";
+    }>;
+    submittedAt: z.ZodISODateTime;
+    decidedAt: z.ZodNullable<z.ZodISODateTime>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const SubmitKycInputSchema: z.ZodObject<{
+    documents: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            passport: "passport";
+            drivers_license: "drivers_license";
+            national_id: "national_id";
+        }>;
+        frontUrl: z.ZodString;
+        backUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SubmitKycInput = z.infer<typeof SubmitKycInputSchema>;
+export declare const PlayerKycViewSchema: z.ZodObject<{
+    current: z.ZodNullable<z.ZodObject<{
+        id: z.ZodUUID;
+        userId: z.ZodUUID;
+        provider: z.ZodString;
+        referenceId: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            not_started: "not_started";
+            verified: "verified";
+            rejected: "rejected";
+            resubmission_requested: "resubmission_requested";
+            manually_overridden: "manually_overridden";
+        }>;
+        documentTypes: z.ZodArray<z.ZodEnum<{
+            passport: "passport";
+            drivers_license: "drivers_license";
+            national_id: "national_id";
+        }>>;
+        decisionReason: z.ZodNullable<z.ZodString>;
+        triggeredBy: z.ZodEnum<{
+            manual: "manual";
+            submission: "submission";
+            reverify_threshold: "reverify_threshold";
+        }>;
+        submittedAt: z.ZodISODateTime;
+        decidedAt: z.ZodNullable<z.ZodISODateTime>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    history: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        userId: z.ZodUUID;
+        provider: z.ZodString;
+        referenceId: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            not_started: "not_started";
+            verified: "verified";
+            rejected: "rejected";
+            resubmission_requested: "resubmission_requested";
+            manually_overridden: "manually_overridden";
+        }>;
+        documentTypes: z.ZodArray<z.ZodEnum<{
+            passport: "passport";
+            drivers_license: "drivers_license";
+            national_id: "national_id";
+        }>>;
+        decisionReason: z.ZodNullable<z.ZodString>;
+        triggeredBy: z.ZodEnum<{
+            manual: "manual";
+            submission: "submission";
+            reverify_threshold: "reverify_threshold";
+        }>;
+        submittedAt: z.ZodISODateTime;
+        decidedAt: z.ZodNullable<z.ZodISODateTime>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PlayerKycView = z.infer<typeof PlayerKycViewSchema>;
+export type KycVerification = z.infer<typeof KycVerificationSchema>;
+export declare const GeoRuleSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    countryCode: z.ZodString;
+    action: z.ZodEnum<{
+        allow: "allow";
+        block: "block";
+    }>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type GeoRule = z.infer<typeof GeoRuleSchema>;
+export declare const AddGeoRuleInputSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        allow: "allow";
+        block: "block";
+    }>;
+    countryCode: z.ZodString;
+}, z.core.$strip>;
+export type AddGeoRuleInput = z.infer<typeof AddGeoRuleInputSchema>;
+export declare const complianceContract: {
+    setPlayerLimit: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        userId: z.ZodUUID;
+        type: z.ZodEnum<{
+            deposit: "deposit";
+            wager: "wager";
+            loss: "loss";
+            session: "session";
+        }>;
+        amount: z.ZodNumber;
+        period: z.ZodEnum<{
+            session: "session";
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        userId: z.ZodUUID;
+        type: z.ZodEnum<{
+            deposit: "deposit";
+            wager: "wager";
+            loss: "loss";
+            session: "session";
+        }>;
+        amount: z.ZodNumber;
+        period: z.ZodEnum<{
+            session: "session";
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+        }>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+    activateCoolingOff: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        userId: z.ZodUUID;
+        durationHours: z.ZodNumber;
+        reason: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        userId: z.ZodUUID;
+        kind: z.ZodEnum<{
+            cooling_off: "cooling_off";
+            self_exclusion: "self_exclusion";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            lifted: "lifted";
+            expired: "expired";
+        }>;
+        reason: z.ZodString;
+        permanent: z.ZodBoolean;
+        startsAt: z.ZodISODateTime;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        liftedAt: z.ZodNullable<z.ZodISODateTime>;
+        liftedReason: z.ZodNullable<z.ZodString>;
+        liftedBy: z.ZodNullable<z.ZodUUID>;
+        createdBy: z.ZodUUID;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+    activateSelfExclusion: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        userId: z.ZodUUID;
+        permanent: z.ZodBoolean;
+        durationMonths: z.ZodOptional<z.ZodNumber>;
+        reason: z.ZodString;
+        confirm: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        userId: z.ZodUUID;
+        kind: z.ZodEnum<{
+            cooling_off: "cooling_off";
+            self_exclusion: "self_exclusion";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            lifted: "lifted";
+            expired: "expired";
+        }>;
+        reason: z.ZodString;
+        permanent: z.ZodBoolean;
+        startsAt: z.ZodISODateTime;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        liftedAt: z.ZodNullable<z.ZodISODateTime>;
+        liftedReason: z.ZodNullable<z.ZodString>;
+        liftedBy: z.ZodNullable<z.ZodUUID>;
+        createdBy: z.ZodUUID;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+    liftSelfExclusion: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        userId: z.ZodUUID;
+        reason: z.ZodString;
+        confirm: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        userId: z.ZodUUID;
+        kind: z.ZodEnum<{
+            cooling_off: "cooling_off";
+            self_exclusion: "self_exclusion";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            lifted: "lifted";
+            expired: "expired";
+        }>;
+        reason: z.ZodString;
+        permanent: z.ZodBoolean;
+        startsAt: z.ZodISODateTime;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        liftedAt: z.ZodNullable<z.ZodISODateTime>;
+        liftedReason: z.ZodNullable<z.ZodString>;
+        liftedBy: z.ZodNullable<z.ZodUUID>;
+        createdBy: z.ZodUUID;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+    getRgSection: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        userId: z.ZodUUID;
+    }, z.core.$strip>, z.ZodObject<{
+        limits: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            userId: z.ZodUUID;
+            type: z.ZodEnum<{
+                deposit: "deposit";
+                wager: "wager";
+                loss: "loss";
+                session: "session";
+            }>;
+            amount: z.ZodNumber;
+            period: z.ZodEnum<{
+                session: "session";
+                daily: "daily";
+                weekly: "weekly";
+                monthly: "monthly";
+            }>;
+            createdAt: z.ZodISODateTime;
+        }, z.core.$strip>>;
+        coolingOff: z.ZodNullable<z.ZodObject<{
+            id: z.ZodUUID;
+            userId: z.ZodUUID;
+            kind: z.ZodEnum<{
+                cooling_off: "cooling_off";
+                self_exclusion: "self_exclusion";
+            }>;
+            status: z.ZodEnum<{
+                active: "active";
+                lifted: "lifted";
+                expired: "expired";
+            }>;
+            reason: z.ZodString;
+            permanent: z.ZodBoolean;
+            startsAt: z.ZodISODateTime;
+            expiresAt: z.ZodNullable<z.ZodISODateTime>;
+            liftedAt: z.ZodNullable<z.ZodISODateTime>;
+            liftedReason: z.ZodNullable<z.ZodString>;
+            liftedBy: z.ZodNullable<z.ZodUUID>;
+            createdBy: z.ZodUUID;
+            createdAt: z.ZodISODateTime;
+            updatedAt: z.ZodISODateTime;
+        }, z.core.$strip>>;
+        selfExclusion: z.ZodNullable<z.ZodObject<{
+            id: z.ZodUUID;
+            userId: z.ZodUUID;
+            kind: z.ZodEnum<{
+                cooling_off: "cooling_off";
+                self_exclusion: "self_exclusion";
+            }>;
+            status: z.ZodEnum<{
+                active: "active";
+                lifted: "lifted";
+                expired: "expired";
+            }>;
+            reason: z.ZodString;
+            permanent: z.ZodBoolean;
+            startsAt: z.ZodISODateTime;
+            expiresAt: z.ZodNullable<z.ZodISODateTime>;
+            liftedAt: z.ZodNullable<z.ZodISODateTime>;
+            liftedReason: z.ZodNullable<z.ZodString>;
+            liftedBy: z.ZodNullable<z.ZodUUID>;
+            createdBy: z.ZodUUID;
+            createdAt: z.ZodISODateTime;
+            updatedAt: z.ZodISODateTime;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+    listRgFlags: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        flagType: z.ZodOptional<z.ZodEnum<{
+            limit_threshold: "limit_threshold";
+            session_time: "session_time";
+            self_excluded_login: "self_excluded_login";
+        }>>;
+        limitType: z.ZodOptional<z.ZodEnum<{
+            deposit: "deposit";
+            wager: "wager";
+            loss: "loss";
+            session: "session";
+        }>>;
+        status: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            cleared: "cleared";
+        }>>;
+        fromDate: z.ZodOptional<z.ZodString>;
+        toDate: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            userId: z.ZodUUID;
+            username: z.ZodNullable<z.ZodString>;
+            email: z.ZodNullable<z.ZodString>;
+            flagType: z.ZodEnum<{
+                limit_threshold: "limit_threshold";
+                session_time: "session_time";
+                self_excluded_login: "self_excluded_login";
+            }>;
+            limitType: z.ZodNullable<z.ZodString>;
+            detail: z.ZodUnion<readonly [z.ZodObject<{
+                actual: z.ZodNumber;
+                limit: z.ZodNumber;
+                period: z.ZodEnum<{
+                    session: "session";
+                    daily: "daily";
+                    weekly: "weekly";
+                    monthly: "monthly";
+                }>;
+                pct: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                sessionMinutes: z.ZodNumber;
+                limitMinutes: z.ZodNumber;
+                pct: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                trigger: z.ZodString;
+                kind: z.ZodNullable<z.ZodEnum<{
+                    cooling_off: "cooling_off";
+                    self_exclusion: "self_exclusion";
+                }>>;
+            }, z.core.$strip>]>;
+            status: z.ZodEnum<{
+                active: "active";
+                cleared: "cleared";
+            }>;
+            flaggedAt: z.ZodISODateTime;
+            clearedAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+        total: z.ZodNumber;
+        page: z.ZodNumber;
+        limit: z.ZodNumber;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+    getLimits: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        userId: z.ZodUUID;
+        type: z.ZodEnum<{
+            deposit: "deposit";
+            wager: "wager";
+            loss: "loss";
+            session: "session";
+        }>;
+        amount: z.ZodNumber;
+        period: z.ZodEnum<{
+            session: "session";
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+        }>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>>, Record<never, never>, Record<never, never>>;
+    upsertLimit: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        type: z.ZodEnum<{
+            deposit: "deposit";
+            wager: "wager";
+            loss: "loss";
+            session: "session";
+        }>;
+        amount: z.ZodNumber;
+        period: z.ZodEnum<{
+            session: "session";
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        userId: z.ZodUUID;
+        type: z.ZodEnum<{
+            deposit: "deposit";
+            wager: "wager";
+            loss: "loss";
+            session: "session";
+        }>;
+        amount: z.ZodNumber;
+        period: z.ZodEnum<{
+            session: "session";
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+        }>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+    deleteLimit: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        id: z.ZodUUID;
+    }, z.core.$strip>, z.ZodObject<{
+        success: z.ZodLiteral<true>;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+    geoCheck: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+        allowed: z.ZodBoolean;
+        countryCode: z.ZodNullable<z.ZodString>;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+    addGeoRule: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        action: z.ZodEnum<{
+            allow: "allow";
+            block: "block";
+        }>;
+        countryCode: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        countryCode: z.ZodString;
+        action: z.ZodEnum<{
+            allow: "allow";
+            block: "block";
+        }>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+    listGeoRules: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        countryCode: z.ZodString;
+        action: z.ZodEnum<{
+            allow: "allow";
+            block: "block";
+        }>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>>, Record<never, never>, Record<never, never>>;
+    getPlayerKyc: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        userId: z.ZodUUID;
+    }, z.core.$strip>, z.ZodObject<{
+        current: z.ZodNullable<z.ZodObject<{
+            id: z.ZodUUID;
+            userId: z.ZodUUID;
+            provider: z.ZodString;
+            referenceId: z.ZodString;
+            status: z.ZodEnum<{
+                pending: "pending";
+                not_started: "not_started";
+                verified: "verified";
+                rejected: "rejected";
+                resubmission_requested: "resubmission_requested";
+                manually_overridden: "manually_overridden";
+            }>;
+            documentTypes: z.ZodArray<z.ZodEnum<{
+                passport: "passport";
+                drivers_license: "drivers_license";
+                national_id: "national_id";
+            }>>;
+            decisionReason: z.ZodNullable<z.ZodString>;
+            triggeredBy: z.ZodEnum<{
+                manual: "manual";
+                submission: "submission";
+                reverify_threshold: "reverify_threshold";
+            }>;
+            submittedAt: z.ZodISODateTime;
+            decidedAt: z.ZodNullable<z.ZodISODateTime>;
+            createdAt: z.ZodISODateTime;
+            updatedAt: z.ZodISODateTime;
+        }, z.core.$strip>>;
+        history: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            userId: z.ZodUUID;
+            provider: z.ZodString;
+            referenceId: z.ZodString;
+            status: z.ZodEnum<{
+                pending: "pending";
+                not_started: "not_started";
+                verified: "verified";
+                rejected: "rejected";
+                resubmission_requested: "resubmission_requested";
+                manually_overridden: "manually_overridden";
+            }>;
+            documentTypes: z.ZodArray<z.ZodEnum<{
+                passport: "passport";
+                drivers_license: "drivers_license";
+                national_id: "national_id";
+            }>>;
+            decisionReason: z.ZodNullable<z.ZodString>;
+            triggeredBy: z.ZodEnum<{
+                manual: "manual";
+                submission: "submission";
+                reverify_threshold: "reverify_threshold";
+            }>;
+            submittedAt: z.ZodISODateTime;
+            decidedAt: z.ZodNullable<z.ZodISODateTime>;
+            createdAt: z.ZodISODateTime;
+            updatedAt: z.ZodISODateTime;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+    submitKyc: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        documents: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                passport: "passport";
+                drivers_license: "drivers_license";
+                national_id: "national_id";
+            }>;
+            frontUrl: z.ZodString;
+            backUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        userId: z.ZodUUID;
+        provider: z.ZodString;
+        referenceId: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            not_started: "not_started";
+            verified: "verified";
+            rejected: "rejected";
+            resubmission_requested: "resubmission_requested";
+            manually_overridden: "manually_overridden";
+        }>;
+        documentTypes: z.ZodArray<z.ZodEnum<{
+            passport: "passport";
+            drivers_license: "drivers_license";
+            national_id: "national_id";
+        }>>;
+        decisionReason: z.ZodNullable<z.ZodString>;
+        triggeredBy: z.ZodEnum<{
+            manual: "manual";
+            submission: "submission";
+            reverify_threshold: "reverify_threshold";
+        }>;
+        submittedAt: z.ZodISODateTime;
+        decidedAt: z.ZodNullable<z.ZodISODateTime>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+    kycWebhook: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+};
+export * from './limits.js';
+export * from './rg.js';
+//# sourceMappingURL=index.d.ts.map