integrateledger 0.0.0-stage → 0.1.0

package/src/lib/url.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+const hasOwn = Object.prototype.hasOwnProperty;
+
+export type Params = Partial<Record<string, string | number>>;
+
+export function pathToFunc(
+  pathPattern: string,
+  options?: { charEncoding?: "percent" | "none" },
+): (params?: Params) => string {
+  const paramRE = /\{([a-zA-Z0-9_][a-zA-Z0-9_-]*?)\}/g;
+
+  return function buildURLPath(params: Record<string, unknown> = {}): string {
+    return pathPattern
+      .replace(paramRE, function (_, placeholder) {
+        if (!hasOwn.call(params, placeholder)) {
+          throw new Error(`Parameter '${placeholder}' is required`);
+        }
+
+        const value = params[placeholder];
+        if (typeof value !== "string" && typeof value !== "number") {
+          throw new Error(
+            `Parameter '${placeholder}' must be a string or number`,
+          );
+        }
+
+        return options?.charEncoding === "percent"
+          ? encodeURIComponent(`${value}`)
+          : `${value}`;
+      })
+      .replace(/^\/+/, "");
+  };
+}

package/src/models/add-on-archived.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type AddOnArchived = {
+  archived: boolean;
+};
+
+/** @internal */
+export const AddOnArchived$inboundSchema: z.ZodMiniType<
+  AddOnArchived,
+  unknown
+> = z.object({
+  archived: types.boolean(),
+});
+
+export function addOnArchivedFromJSON(
+  jsonString: string,
+): SafeParseResult<AddOnArchived, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddOnArchived$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddOnArchived' from JSON`,
+  );
+}

package/src/models/add-on-attach-input.ts

@@ -0,0 +1,34 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type AddOnAttachInput = {
+  customerId: string;
+  addOnId: string;
+  planId?: never;
+};
+
+/** @internal */
+export type AddOnAttachInput$Outbound = {
+  customerId: string;
+  addOnId: string;
+};
+
+/** @internal */
+export const AddOnAttachInput$outboundSchema: z.ZodMiniType<
+  AddOnAttachInput$Outbound,
+  AddOnAttachInput
+> = z.strictObject({
+  customerId: z.string(),
+  addOnId: z.string(),
+});
+
+export function addOnAttachInputToJSON(
+  addOnAttachInput: AddOnAttachInput,
+): string {
+  return JSON.stringify(
+    AddOnAttachInput$outboundSchema.parse(addOnAttachInput),
+  );
+}

package/src/models/add-on-attach-response.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type AddOnAttachResponse = {
+  checkoutUrl: string;
+  addOnPurchaseId: number;
+};
+
+/** @internal */
+export const AddOnAttachResponse$inboundSchema: z.ZodMiniType<
+  AddOnAttachResponse,
+  unknown
+> = z.object({
+  checkoutUrl: types.string(),
+  addOnPurchaseId: types.number(),
+});
+
+export function addOnAttachResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<AddOnAttachResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddOnAttachResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddOnAttachResponse' from JSON`,
+  );
+}

package/src/models/add-on-item.ts

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export const AddOnItemType = {
+  CreditPack: "credit_pack",
+} as const;
+export type AddOnItemType = OpenEnum<typeof AddOnItemType>;
+
+export type AddOnItem = {
+  id: string;
+  name: string;
+  type: AddOnItemType;
+  creditAmount: number;
+  priceCents: number;
+};
+
+/** @internal */
+export const AddOnItemType$inboundSchema: z.ZodMiniType<
+  AddOnItemType,
+  unknown
+> = openEnums.inboundSchema(AddOnItemType);
+
+/** @internal */
+export const AddOnItem$inboundSchema: z.ZodMiniType<AddOnItem, unknown> = z
+  .object({
+    id: types.string(),
+    name: types.string(),
+    type: AddOnItemType$inboundSchema,
+    creditAmount: types.number(),
+    priceCents: types.number(),
+  });
+
+export function addOnItemFromJSON(
+  jsonString: string,
+): SafeParseResult<AddOnItem, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddOnItem$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddOnItem' from JSON`,
+  );
+}

package/src/models/add-on-list.ts

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AddOnItem, AddOnItem$inboundSchema } from "./add-on-item.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type AddOnList = {
+  items: Array<AddOnItem>;
+};
+
+/** @internal */
+export const AddOnList$inboundSchema: z.ZodMiniType<AddOnList, unknown> = z
+  .object({
+    items: z.array(AddOnItem$inboundSchema),
+  });
+
+export function addOnListFromJSON(
+  jsonString: string,
+): SafeParseResult<AddOnList, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddOnList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddOnList' from JSON`,
+  );
+}

package/src/models/add-on-mutation.ts

@@ -0,0 +1,34 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { AddOnItem, AddOnItem$inboundSchema } from "./add-on-item.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type AddOnMutation = {
+  item: AddOnItem;
+  changed: boolean;
+};
+
+/** @internal */
+export const AddOnMutation$inboundSchema: z.ZodMiniType<
+  AddOnMutation,
+  unknown
+> = z.object({
+  item: AddOnItem$inboundSchema,
+  changed: types.boolean(),
+});
+
+export function addOnMutationFromJSON(
+  jsonString: string,
+): SafeParseResult<AddOnMutation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddOnMutation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddOnMutation' from JSON`,
+  );
+}

package/src/models/attach-input.ts

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { smartUnion } from "../types/smart-union.js";
+import {
+  AddOnAttachInput,
+  AddOnAttachInput$Outbound,
+  AddOnAttachInput$outboundSchema,
+} from "./add-on-attach-input.js";
+import {
+  PlanAttachInput,
+  PlanAttachInput$Outbound,
+  PlanAttachInput$outboundSchema,
+} from "./plan-attach-input.js";
+
+export type AttachInput = PlanAttachInput | AddOnAttachInput;
+
+/** @internal */
+export type AttachInput$Outbound =
+  | PlanAttachInput$Outbound
+  | AddOnAttachInput$Outbound;
+
+/** @internal */
+export const AttachInput$outboundSchema: z.ZodMiniType<
+  AttachInput$Outbound,
+  AttachInput
+> = smartUnion([
+  PlanAttachInput$outboundSchema,
+  AddOnAttachInput$outboundSchema,
+]);
+
+export function attachInputToJSON(attachInput: AttachInput): string {
+  return JSON.stringify(AttachInput$outboundSchema.parse(attachInput));
+}

package/src/models/attach-response.ts

@@ -0,0 +1,46 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { smartUnion } from "../types/smart-union.js";
+import {
+  AddOnAttachResponse,
+  AddOnAttachResponse$inboundSchema,
+} from "./add-on-attach-response.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  FreePlanAttachResponse,
+  FreePlanAttachResponse$inboundSchema,
+} from "./free-plan-attach-response.js";
+import {
+  PlanAttachResponse,
+  PlanAttachResponse$inboundSchema,
+} from "./plan-attach-response.js";
+
+export type AttachResponse =
+  | PlanAttachResponse
+  | AddOnAttachResponse
+  | FreePlanAttachResponse;
+
+/** @internal */
+export const AttachResponse$inboundSchema: z.ZodMiniType<
+  AttachResponse,
+  unknown
+> = smartUnion([
+  PlanAttachResponse$inboundSchema,
+  AddOnAttachResponse$inboundSchema,
+  FreePlanAttachResponse$inboundSchema,
+]);
+
+export function attachResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<AttachResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AttachResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AttachResponse' from JSON`,
+  );
+}

package/src/models/catalog-error.ts

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type Issue = {
+  path: string;
+  message: string;
+};
+
+/** @internal */
+export const Issue$inboundSchema: z.ZodMiniType<Issue, unknown> = z.object({
+  path: types.string(),
+  message: types.string(),
+});
+
+export function issueFromJSON(
+  jsonString: string,
+): SafeParseResult<Issue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Issue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Issue' from JSON`,
+  );
+}

package/src/models/catalog-input.ts

@@ -0,0 +1,198 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { ClosedEnum } from "../types/enums.js";
+
+export const SchemaVersion = {
+  One: 1,
+} as const;
+export type SchemaVersion = ClosedEnum<typeof SchemaVersion>;
+
+export const Environment = {
+  Sandbox: "sandbox",
+  Live: "live",
+} as const;
+export type Environment = ClosedEnum<typeof Environment>;
+
+export const Currency = {
+  Usd: "usd",
+} as const;
+export type Currency = ClosedEnum<typeof Currency>;
+
+export type Plan = {
+  id: string;
+  name: string;
+  monthlyCredits: number;
+  monthlyPriceCents: number;
+};
+
+export type Feature = {
+  id: string;
+  name: string;
+  creditCost: number;
+};
+
+export const CatalogInputType = {
+  CreditPack: "credit_pack",
+} as const;
+export type CatalogInputType = ClosedEnum<typeof CatalogInputType>;
+
+export type AddOn = {
+  id: string;
+  name: string;
+  type: CatalogInputType;
+  creditAmount: number;
+  priceCents: number;
+};
+
+export const OnInsufficientCredits = {
+  Block: "block",
+} as const;
+export type OnInsufficientCredits = ClosedEnum<typeof OnInsufficientCredits>;
+
+export type Policy = {
+  onInsufficientCredits: OnInsufficientCredits;
+};
+
+export type CatalogInput = {
+  schemaVersion: SchemaVersion;
+  environment: Environment;
+  currency: Currency;
+  plans: Array<Plan>;
+  features: Array<Feature>;
+  addOns: Array<AddOn>;
+  policy: Policy;
+};
+
+/** @internal */
+export const SchemaVersion$outboundSchema: z.ZodMiniEnum<typeof SchemaVersion> =
+  z.enum(SchemaVersion);
+
+/** @internal */
+export const Environment$outboundSchema: z.ZodMiniEnum<typeof Environment> = z
+  .enum(Environment);
+
+/** @internal */
+export const Currency$outboundSchema: z.ZodMiniEnum<typeof Currency> = z.enum(
+  Currency,
+);
+
+/** @internal */
+export type Plan$Outbound = {
+  id: string;
+  name: string;
+  monthlyCredits: number;
+  monthlyPriceCents: number;
+};
+
+/** @internal */
+export const Plan$outboundSchema: z.ZodMiniType<Plan$Outbound, Plan> = z.object(
+  {
+    id: z.string(),
+    name: z.string(),
+    monthlyCredits: z.int(),
+    monthlyPriceCents: z.int(),
+  },
+);
+
+export function planToJSON(plan: Plan): string {
+  return JSON.stringify(Plan$outboundSchema.parse(plan));
+}
+
+/** @internal */
+export type Feature$Outbound = {
+  id: string;
+  name: string;
+  creditCost: number;
+};
+
+/** @internal */
+export const Feature$outboundSchema: z.ZodMiniType<Feature$Outbound, Feature> =
+  z.object({
+    id: z.string(),
+    name: z.string(),
+    creditCost: z.int(),
+  });
+
+export function featureToJSON(feature: Feature): string {
+  return JSON.stringify(Feature$outboundSchema.parse(feature));
+}
+
+/** @internal */
+export const CatalogInputType$outboundSchema: z.ZodMiniEnum<
+  typeof CatalogInputType
+> = z.enum(CatalogInputType);
+
+/** @internal */
+export type AddOn$Outbound = {
+  id: string;
+  name: string;
+  type: string;
+  creditAmount: number;
+  priceCents: number;
+};
+
+/** @internal */
+export const AddOn$outboundSchema: z.ZodMiniType<AddOn$Outbound, AddOn> = z
+  .object({
+    id: z.string(),
+    name: z.string(),
+    type: CatalogInputType$outboundSchema,
+    creditAmount: z.int(),
+    priceCents: z.int(),
+  });
+
+export function addOnToJSON(addOn: AddOn): string {
+  return JSON.stringify(AddOn$outboundSchema.parse(addOn));
+}
+
+/** @internal */
+export const OnInsufficientCredits$outboundSchema: z.ZodMiniEnum<
+  typeof OnInsufficientCredits
+> = z.enum(OnInsufficientCredits);
+
+/** @internal */
+export type Policy$Outbound = {
+  onInsufficientCredits: string;
+};
+
+/** @internal */
+export const Policy$outboundSchema: z.ZodMiniType<Policy$Outbound, Policy> = z
+  .object({
+    onInsufficientCredits: OnInsufficientCredits$outboundSchema,
+  });
+
+export function policyToJSON(policy: Policy): string {
+  return JSON.stringify(Policy$outboundSchema.parse(policy));
+}
+
+/** @internal */
+export type CatalogInput$Outbound = {
+  schemaVersion: number;
+  environment: string;
+  currency: string;
+  plans: Array<Plan$Outbound>;
+  features: Array<Feature$Outbound>;
+  addOns: Array<AddOn$Outbound>;
+  policy: Policy$Outbound;
+};
+
+/** @internal */
+export const CatalogInput$outboundSchema: z.ZodMiniType<
+  CatalogInput$Outbound,
+  CatalogInput
+> = z.object({
+  schemaVersion: SchemaVersion$outboundSchema,
+  environment: Environment$outboundSchema,
+  currency: Currency$outboundSchema,
+  plans: z.array(z.lazy(() => Plan$outboundSchema)),
+  features: z.array(z.lazy(() => Feature$outboundSchema)),
+  addOns: z.array(z.lazy(() => AddOn$outboundSchema)),
+  policy: z.lazy(() => Policy$outboundSchema),
+});
+
+export function catalogInputToJSON(catalogInput: CatalogInput): string {
+  return JSON.stringify(CatalogInput$outboundSchema.parse(catalogInput));
+}

package/src/models/catalog-publish-response.ts

@@ -0,0 +1,51 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export const CatalogPublishResponseStripeSync = {
+  Synced: "synced",
+  Pending: "pending",
+  Failed: "failed",
+  AwaitingConnection: "awaiting_connection",
+} as const;
+export type CatalogPublishResponseStripeSync = OpenEnum<
+  typeof CatalogPublishResponseStripeSync
+>;
+
+export type CatalogPublishResponse = {
+  changed: boolean;
+  stripeSync: CatalogPublishResponseStripeSync;
+};
+
+/** @internal */
+export const CatalogPublishResponseStripeSync$inboundSchema: z.ZodMiniType<
+  CatalogPublishResponseStripeSync,
+  unknown
+> = openEnums.inboundSchema(CatalogPublishResponseStripeSync);
+
+/** @internal */
+export const CatalogPublishResponse$inboundSchema: z.ZodMiniType<
+  CatalogPublishResponse,
+  unknown
+> = z.object({
+  changed: types.boolean(),
+  stripeSync: CatalogPublishResponseStripeSync$inboundSchema,
+});
+
+export function catalogPublishResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CatalogPublishResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CatalogPublishResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CatalogPublishResponse' from JSON`,
+  );
+}

package/src/models/check-input.ts

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type CheckInput = {
+  customerId: string;
+  featureId: string;
+};
+
+/** @internal */
+export type CheckInput$Outbound = {
+  customerId: string;
+  featureId: string;
+};
+
+/** @internal */
+export const CheckInput$outboundSchema: z.ZodMiniType<
+  CheckInput$Outbound,
+  CheckInput
+> = z.object({
+  customerId: z.string(),
+  featureId: z.string(),
+});
+
+export function checkInputToJSON(checkInput: CheckInput): string {
+  return JSON.stringify(CheckInput$outboundSchema.parse(checkInput));
+}

package/src/models/check-response.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type CheckResponse = {
+  allowed: boolean;
+  availableCredits: number;
+  creditCost: number;
+};
+
+/** @internal */
+export const CheckResponse$inboundSchema: z.ZodMiniType<
+  CheckResponse,
+  unknown
+> = z.object({
+  allowed: types.boolean(),
+  availableCredits: types.number(),
+  creditCost: types.number(),
+});
+
+export function checkResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CheckResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CheckResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CheckResponse' from JSON`,
+  );
+}