@crevio/sdk 0.4.12 → 0.4.14

package/src/models/subscription.ts

@@ -8,21 +8,170 @@ import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
+export type SubscriptionStatus = {};
+
+export type Quantity = {};
+
+export type CurrentPeriodStart = {};
+
+export type CurrentPeriodEnd = {};
+
+export type TrialEndsAt = {};
+
+export type EndsAt = {};
+
+export type SubscriptionCreatedAt = {};
+
+export type SubscriptionUpdatedAt = {};
+
 export type Subscription = {
   id: string;
   object: string;
-  status: string;
-  quantity: number;
-  currentPeriodStart: string;
-  currentPeriodEnd: string;
-  trialEndsAt: string;
-  endsAt: string;
-  createdAt: string;
-  updatedAt: string;
+  status: SubscriptionStatus;
+  quantity: Quantity;
+  currentPeriodStart: CurrentPeriodStart;
+  currentPeriodEnd: CurrentPeriodEnd;
+  trialEndsAt: TrialEndsAt;
+  endsAt: EndsAt;
+  createdAt: SubscriptionCreatedAt;
+  updatedAt: SubscriptionUpdatedAt;
   canceled: boolean;
   paused: boolean;
 };
 
+/** @internal */
+export const SubscriptionStatus$inboundSchema: z.ZodType<
+  SubscriptionStatus,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function subscriptionStatusFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionStatus, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SubscriptionStatus$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionStatus' from JSON`,
+  );
+}
+
+/** @internal */
+export const Quantity$inboundSchema: z.ZodType<
+  Quantity,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function quantityFromJSON(
+  jsonString: string,
+): SafeParseResult<Quantity, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Quantity$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Quantity' from JSON`,
+  );
+}
+
+/** @internal */
+export const CurrentPeriodStart$inboundSchema: z.ZodType<
+  CurrentPeriodStart,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function currentPeriodStartFromJSON(
+  jsonString: string,
+): SafeParseResult<CurrentPeriodStart, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CurrentPeriodStart$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CurrentPeriodStart' from JSON`,
+  );
+}
+
+/** @internal */
+export const CurrentPeriodEnd$inboundSchema: z.ZodType<
+  CurrentPeriodEnd,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function currentPeriodEndFromJSON(
+  jsonString: string,
+): SafeParseResult<CurrentPeriodEnd, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CurrentPeriodEnd$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CurrentPeriodEnd' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrialEndsAt$inboundSchema: z.ZodType<
+  TrialEndsAt,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function trialEndsAtFromJSON(
+  jsonString: string,
+): SafeParseResult<TrialEndsAt, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrialEndsAt$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrialEndsAt' from JSON`,
+  );
+}
+
+/** @internal */
+export const EndsAt$inboundSchema: z.ZodType<EndsAt, z.ZodTypeDef, unknown> = z
+  .object({});
+
+export function endsAtFromJSON(
+  jsonString: string,
+): SafeParseResult<EndsAt, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EndsAt$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EndsAt' from JSON`,
+  );
+}
+
+/** @internal */
+export const SubscriptionCreatedAt$inboundSchema: z.ZodType<
+  SubscriptionCreatedAt,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function subscriptionCreatedAtFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionCreatedAt, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SubscriptionCreatedAt$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionCreatedAt' from JSON`,
+  );
+}
+
+/** @internal */
+export const SubscriptionUpdatedAt$inboundSchema: z.ZodType<
+  SubscriptionUpdatedAt,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function subscriptionUpdatedAtFromJSON(
+  jsonString: string,
+): SafeParseResult<SubscriptionUpdatedAt, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SubscriptionUpdatedAt$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SubscriptionUpdatedAt' from JSON`,
+  );
+}
+
 /** @internal */
 export const Subscription$inboundSchema: z.ZodType<
   Subscription,
@@ -31,14 +180,14 @@ export const Subscription$inboundSchema: z.ZodType<
 > = z.object({
   id: z.string(),
   object: z.string(),
-  status: z.string(),
-  quantity: z.number().int(),
-  current_period_start: z.string(),
-  current_period_end: z.string(),
-  trial_ends_at: z.string(),
-  ends_at: z.string(),
-  created_at: z.string(),
-  updated_at: z.string(),
+  status: z.lazy(() => SubscriptionStatus$inboundSchema),
+  quantity: z.lazy(() => Quantity$inboundSchema),
+  current_period_start: z.lazy(() => CurrentPeriodStart$inboundSchema),
+  current_period_end: z.lazy(() => CurrentPeriodEnd$inboundSchema),
+  trial_ends_at: z.lazy(() => TrialEndsAt$inboundSchema),
+  ends_at: z.lazy(() => EndsAt$inboundSchema),
+  created_at: z.lazy(() => SubscriptionCreatedAt$inboundSchema),
+  updated_at: z.lazy(() => SubscriptionUpdatedAt$inboundSchema),
   canceled: z.boolean(),
   paused: z.boolean(),
 }).transform((v) => {

package/src/models/tag.ts

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type Tag = {
+  id: string;
+  object: string;
+  name: string;
+  createdAt: Date;
+  updatedAt: Date;
+  customersCount: number;
+};
+
+/** @internal */
+export const Tag$inboundSchema: z.ZodType<Tag, z.ZodTypeDef, unknown> = z
+  .object({
+    id: z.string(),
+    object: z.string(),
+    name: z.string(),
+    created_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ),
+    updated_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ),
+    customers_count: z.number(),
+  }).transform((v) => {
+    return remap$(v, {
+      "created_at": "createdAt",
+      "updated_at": "updatedAt",
+      "customers_count": "customersCount",
+    });
+  });
+
+export function tagFromJSON(
+  jsonString: string,
+): SafeParseResult<Tag, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Tag$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Tag' from JSON`,
+  );
+}

package/src/models/tagrequest.ts

@@ -0,0 +1,27 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type TagRequest = {
+  name?: string | undefined;
+};
+
+/** @internal */
+export type TagRequest$Outbound = {
+  name?: string | undefined;
+};
+
+/** @internal */
+export const TagRequest$outboundSchema: z.ZodType<
+  TagRequest$Outbound,
+  z.ZodTypeDef,
+  TagRequest
+> = z.object({
+  name: z.string().optional(),
+});
+
+export function tagRequestToJSON(tagRequest: TagRequest): string {
+  return JSON.stringify(TagRequest$outboundSchema.parse(tagRequest));
+}

package/src/models/webhookendpointrequest.ts

@@ -14,33 +14,29 @@ export type WebhookEndpointRequestStatus = ClosedEnum<
   typeof WebhookEndpointRequestStatus
 >;
 
-export type WebhookEndpointRequestWebhookEndpoint = {
+export type WebhookEndpointRequest = {
   url?: string | undefined;
   status?: WebhookEndpointRequestStatus | undefined;
   enabledEvents?: Array<string> | undefined;
 };
 
-export type WebhookEndpointRequest = {
-  webhookEndpoint: WebhookEndpointRequestWebhookEndpoint;
-};
-
 /** @internal */
 export const WebhookEndpointRequestStatus$outboundSchema: z.ZodNativeEnum<
   typeof WebhookEndpointRequestStatus
 > = z.nativeEnum(WebhookEndpointRequestStatus);
 
 /** @internal */
-export type WebhookEndpointRequestWebhookEndpoint$Outbound = {
+export type WebhookEndpointRequest$Outbound = {
   url?: string | undefined;
   status?: string | undefined;
   enabled_events?: Array<string> | undefined;
 };
 
 /** @internal */
-export const WebhookEndpointRequestWebhookEndpoint$outboundSchema: z.ZodType<
-  WebhookEndpointRequestWebhookEndpoint$Outbound,
+export const WebhookEndpointRequest$outboundSchema: z.ZodType<
+  WebhookEndpointRequest$Outbound,
   z.ZodTypeDef,
-  WebhookEndpointRequestWebhookEndpoint
+  WebhookEndpointRequest
 > = z.object({
   url: z.string().optional(),
   status: WebhookEndpointRequestStatus$outboundSchema.optional(),
@@ -51,36 +47,6 @@ export const WebhookEndpointRequestWebhookEndpoint$outboundSchema: z.ZodType<
   });
 });
 
-export function webhookEndpointRequestWebhookEndpointToJSON(
-  webhookEndpointRequestWebhookEndpoint: WebhookEndpointRequestWebhookEndpoint,
-): string {
-  return JSON.stringify(
-    WebhookEndpointRequestWebhookEndpoint$outboundSchema.parse(
-      webhookEndpointRequestWebhookEndpoint,
-    ),
-  );
-}
-
-/** @internal */
-export type WebhookEndpointRequest$Outbound = {
-  webhook_endpoint: WebhookEndpointRequestWebhookEndpoint$Outbound;
-};
-
-/** @internal */
-export const WebhookEndpointRequest$outboundSchema: z.ZodType<
-  WebhookEndpointRequest$Outbound,
-  z.ZodTypeDef,
-  WebhookEndpointRequest
-> = z.object({
-  webhookEndpoint: z.lazy(() =>
-    WebhookEndpointRequestWebhookEndpoint$outboundSchema
-  ),
-}).transform((v) => {
-  return remap$(v, {
-    webhookEndpoint: "webhook_endpoint",
-  });
-});
-
 export function webhookEndpointRequestToJSON(
   webhookEndpointRequest: WebhookEndpointRequest,
 ): string {

package/src/models/webhookevent.ts

@@ -0,0 +1,103 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export const WebhookEventStatus = {
+  Pending: "pending",
+  Delivered: "delivered",
+  Failed: "failed",
+} as const;
+export type WebhookEventStatus = ClosedEnum<typeof WebhookEventStatus>;
+
+export type Data = {};
+
+export type RequestT = {};
+
+export type WebhookEvent = {
+  object: string;
+  id: string;
+  eventType: string;
+  status: WebhookEventStatus;
+  createdAt: Date;
+  data: Data;
+  apiVersion: string;
+  webhookEndpoint: string;
+  request: RequestT;
+};
+
+/** @internal */
+export const WebhookEventStatus$inboundSchema: z.ZodNativeEnum<
+  typeof WebhookEventStatus
+> = z.nativeEnum(WebhookEventStatus);
+
+/** @internal */
+export const Data$inboundSchema: z.ZodType<Data, z.ZodTypeDef, unknown> = z
+  .object({});
+
+export function dataFromJSON(
+  jsonString: string,
+): SafeParseResult<Data, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Data$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Data' from JSON`,
+  );
+}
+
+/** @internal */
+export const RequestT$inboundSchema: z.ZodType<
+  RequestT,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function requestFromJSON(
+  jsonString: string,
+): SafeParseResult<RequestT, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RequestT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RequestT' from JSON`,
+  );
+}
+
+/** @internal */
+export const WebhookEvent$inboundSchema: z.ZodType<
+  WebhookEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: z.string(),
+  id: z.string(),
+  event_type: z.string(),
+  status: WebhookEventStatus$inboundSchema,
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  data: z.lazy(() => Data$inboundSchema),
+  api_version: z.string(),
+  webhook_endpoint: z.string(),
+  request: z.lazy(() => RequestT$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "event_type": "eventType",
+    "created_at": "createdAt",
+    "api_version": "apiVersion",
+    "webhook_endpoint": "webhookEndpoint",
+  });
+});
+
+export function webhookEventFromJSON(
+  jsonString: string,
+): SafeParseResult<WebhookEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WebhookEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WebhookEvent' from JSON`,
+  );
+}

package/src/models/x402configuration.ts

@@ -8,14 +8,71 @@ import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
+export type X402Enabled = {};
+
+export type X402WalletAddress = {};
+
+export type X402Chain = {};
+
 export type X402Configuration = {
   object: string;
-  x402Enabled: boolean;
-  x402WalletAddress: string;
-  x402Chain: string;
+  x402Enabled: X402Enabled;
+  x402WalletAddress: X402WalletAddress;
+  x402Chain: X402Chain;
   currency: string;
 };
 
+/** @internal */
+export const X402Enabled$inboundSchema: z.ZodType<
+  X402Enabled,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function x402EnabledFromJSON(
+  jsonString: string,
+): SafeParseResult<X402Enabled, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => X402Enabled$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'X402Enabled' from JSON`,
+  );
+}
+
+/** @internal */
+export const X402WalletAddress$inboundSchema: z.ZodType<
+  X402WalletAddress,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function x402WalletAddressFromJSON(
+  jsonString: string,
+): SafeParseResult<X402WalletAddress, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => X402WalletAddress$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'X402WalletAddress' from JSON`,
+  );
+}
+
+/** @internal */
+export const X402Chain$inboundSchema: z.ZodType<
+  X402Chain,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function x402ChainFromJSON(
+  jsonString: string,
+): SafeParseResult<X402Chain, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => X402Chain$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'X402Chain' from JSON`,
+  );
+}
+
 /** @internal */
 export const X402Configuration$inboundSchema: z.ZodType<
   X402Configuration,
@@ -23,9 +80,9 @@ export const X402Configuration$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   object: z.string(),
-  x402_enabled: z.boolean(),
-  x402_wallet_address: z.string(),
-  x402_chain: z.string(),
+  x402_enabled: z.lazy(() => X402Enabled$inboundSchema),
+  x402_wallet_address: z.lazy(() => X402WalletAddress$inboundSchema),
+  x402_chain: z.lazy(() => X402Chain$inboundSchema),
   currency: z.string(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/x402configurationrequest.ts

@@ -5,69 +5,33 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 
-export type X402ConfigurationRequestX402Configuration = {
+export type X402ConfigurationRequest = {
   x402Enabled?: boolean | undefined;
   x402WalletAddress?: string | null | undefined;
   x402Chain?: string | null | undefined;
 };
 
-export type X402ConfigurationRequest = {
-  x402Configuration: X402ConfigurationRequestX402Configuration;
-};
-
 /** @internal */
-export type X402ConfigurationRequestX402Configuration$Outbound = {
+export type X402ConfigurationRequest$Outbound = {
   x402_enabled?: boolean | undefined;
   x402_wallet_address?: string | null | undefined;
   x402_chain?: string | null | undefined;
 };
 
-/** @internal */
-export const X402ConfigurationRequestX402Configuration$outboundSchema:
-  z.ZodType<
-    X402ConfigurationRequestX402Configuration$Outbound,
-    z.ZodTypeDef,
-    X402ConfigurationRequestX402Configuration
-  > = z.object({
-    x402Enabled: z.boolean().optional(),
-    x402WalletAddress: z.nullable(z.string()).optional(),
-    x402Chain: z.nullable(z.string()).optional(),
-  }).transform((v) => {
-    return remap$(v, {
-      x402Enabled: "x402_enabled",
-      x402WalletAddress: "x402_wallet_address",
-      x402Chain: "x402_chain",
-    });
-  });
-
-export function x402ConfigurationRequestX402ConfigurationToJSON(
-  x402ConfigurationRequestX402Configuration:
-    X402ConfigurationRequestX402Configuration,
-): string {
-  return JSON.stringify(
-    X402ConfigurationRequestX402Configuration$outboundSchema.parse(
-      x402ConfigurationRequestX402Configuration,
-    ),
-  );
-}
-
-/** @internal */
-export type X402ConfigurationRequest$Outbound = {
-  x402_configuration: X402ConfigurationRequestX402Configuration$Outbound;
-};
-
 /** @internal */
 export const X402ConfigurationRequest$outboundSchema: z.ZodType<
   X402ConfigurationRequest$Outbound,
   z.ZodTypeDef,
   X402ConfigurationRequest
 > = z.object({
-  x402Configuration: z.lazy(() =>
-    X402ConfigurationRequestX402Configuration$outboundSchema
-  ),
+  x402Enabled: z.boolean().optional(),
+  x402WalletAddress: z.nullable(z.string()).optional(),
+  x402Chain: z.nullable(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
-    x402Configuration: "x402_configuration",
+    x402Enabled: "x402_enabled",
+    x402WalletAddress: "x402_wallet_address",
+    x402Chain: "x402_chain",
   });
 });
 

package/src/sdk/account.ts

@@ -3,6 +3,7 @@
  */
 
 import { accountGet } from "../funcs/accountGet.js";
+import { accountUpdate } from "../funcs/accountUpdate.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as models from "../models/index.js";
 import { unwrapAsync } from "../types/fp.js";
@@ -22,4 +23,21 @@ export class Account extends ClientSDK {
       options,
     ));
   }
+
+  /**
+   * Update current account
+   *
+   * @remarks
+   * Updates the authenticated account's information
+   */
+  async update(
+    request: models.AccountRequest,
+    options?: RequestOptions,
+  ): Promise<models.Account> {
+    return unwrapAsync(accountUpdate(
+      this,
+      request,
+      options,
+    ));
+  }
 }

package/src/sdk/blogcategories.ts

@@ -0,0 +1,46 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { blogCategoriesGet } from "../funcs/blogCategoriesGet.js";
+import { blogCategoriesList } from "../funcs/blogCategoriesList.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class BlogCategories extends ClientSDK {
+  /**
+   * List blog categories
+   *
+   * @remarks
+   * Returns a list of blog categories for the current account
+   */
+  async list(
+    request?: operations.ListBlogCategoriesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListResponseBlogCategory> {
+    return unwrapAsync(blogCategoriesList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get blog category
+   *
+   * @remarks
+   * Returns a specific blog category
+   */
+  async get(
+    request: operations.GetBlogCategoryRequest,
+    options?: RequestOptions,
+  ): Promise<models.BlogCategory> {
+    return unwrapAsync(blogCategoriesGet(
+      this,
+      request,
+      options,
+    ));
+  }
+}