@usestatemachines/sdk 0.1.1

package/esm/models/operations/list-workspaces.d.ts

@@ -0,0 +1,32 @@
+import * as z from "zod/v4-mini";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+export declare const Archived: {
+    readonly Exclude: "exclude";
+    readonly Include: "include";
+    readonly Only: "only";
+};
+export type Archived = ClosedEnum<typeof Archived>;
+export type ListWorkspacesRequest = {
+    archived?: Archived | undefined;
+};
+/**
+ * The current organization's workspaces
+ */
+export type ListWorkspacesResponse = {
+    data: Array<models.Workspace>;
+};
+/** @internal */
+export declare const Archived$outboundSchema: z.ZodMiniEnum<typeof Archived>;
+/** @internal */
+export type ListWorkspacesRequest$Outbound = {
+    archived: string;
+};
+/** @internal */
+export declare const ListWorkspacesRequest$outboundSchema: z.ZodMiniType<ListWorkspacesRequest$Outbound, ListWorkspacesRequest>;
+export declare function listWorkspacesRequestToJSON(listWorkspacesRequest: ListWorkspacesRequest): string;
+/** @internal */
+export declare const ListWorkspacesResponse$inboundSchema: z.ZodMiniType<ListWorkspacesResponse, unknown>;
+export declare function listWorkspacesResponseFromJSON(jsonString: string): SafeParseResult<ListWorkspacesResponse, SDKValidationError>;

package/esm/models/operations/list-workspaces.js

@@ -0,0 +1,27 @@
+/*
+ * 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 models from "../index.js";
+export const Archived = {
+    Exclude: "exclude",
+    Include: "include",
+    Only: "only",
+};
+/** @internal */
+export const Archived$outboundSchema = z.enum(Archived);
+/** @internal */
+export const ListWorkspacesRequest$outboundSchema = z.object({
+    archived: z._default(Archived$outboundSchema, "exclude"),
+});
+export function listWorkspacesRequestToJSON(listWorkspacesRequest) {
+    return JSON.stringify(ListWorkspacesRequest$outboundSchema.parse(listWorkspacesRequest));
+}
+/** @internal */
+export const ListWorkspacesResponse$inboundSchema = z.object({
+    data: z.array(models.Workspace$inboundSchema),
+});
+export function listWorkspacesResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ListWorkspacesResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ListWorkspacesResponse' from JSON`);
+}

package/esm/models/operations/reveal-connection.d.ts

@@ -0,0 +1,37 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+export type RevealConnectionRequestBody = {
+    actorId: string;
+};
+export type RevealConnectionRequest = {
+    environmentId: string;
+    appKey: string;
+    body: RevealConnectionRequestBody;
+};
+/**
+ * Live credentials for one actor; recorded as an event
+ */
+export type RevealConnectionResponse = {
+    data: models.ConnectionSecret;
+};
+/** @internal */
+export type RevealConnectionRequestBody$Outbound = {
+    actorId: string;
+};
+/** @internal */
+export declare const RevealConnectionRequestBody$outboundSchema: z.ZodMiniType<RevealConnectionRequestBody$Outbound, RevealConnectionRequestBody>;
+export declare function revealConnectionRequestBodyToJSON(revealConnectionRequestBody: RevealConnectionRequestBody): string;
+/** @internal */
+export type RevealConnectionRequest$Outbound = {
+    environmentId: string;
+    appKey: string;
+    body: RevealConnectionRequestBody$Outbound;
+};
+/** @internal */
+export declare const RevealConnectionRequest$outboundSchema: z.ZodMiniType<RevealConnectionRequest$Outbound, RevealConnectionRequest>;
+export declare function revealConnectionRequestToJSON(revealConnectionRequest: RevealConnectionRequest): string;
+/** @internal */
+export declare const RevealConnectionResponse$inboundSchema: z.ZodMiniType<RevealConnectionResponse, unknown>;
+export declare function revealConnectionResponseFromJSON(jsonString: string): SafeParseResult<RevealConnectionResponse, SDKValidationError>;

package/esm/models/operations/reveal-connection.js

@@ -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 * as models from "../index.js";
+/** @internal */
+export const RevealConnectionRequestBody$outboundSchema = z.object({
+    actorId: z.string(),
+});
+export function revealConnectionRequestBodyToJSON(revealConnectionRequestBody) {
+    return JSON.stringify(RevealConnectionRequestBody$outboundSchema.parse(revealConnectionRequestBody));
+}
+/** @internal */
+export const RevealConnectionRequest$outboundSchema = z.object({
+    environmentId: z.string(),
+    appKey: z.string(),
+    body: z.lazy(() => RevealConnectionRequestBody$outboundSchema),
+});
+export function revealConnectionRequestToJSON(revealConnectionRequest) {
+    return JSON.stringify(RevealConnectionRequest$outboundSchema.parse(revealConnectionRequest));
+}
+/** @internal */
+export const RevealConnectionResponse$inboundSchema = z.object({
+    data: models.ConnectionSecret$inboundSchema,
+});
+export function revealConnectionResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => RevealConnectionResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RevealConnectionResponse' from JSON`);
+}

package/esm/models/operations/stop-environment.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+export type StopEnvironmentRequest = {
+    environmentId: string;
+};
+/**
+ * Environment stopped or stopping
+ */
+export type StopEnvironmentResponse = {
+    data: models.Environment;
+};
+/** @internal */
+export type StopEnvironmentRequest$Outbound = {
+    environmentId: string;
+};
+/** @internal */
+export declare const StopEnvironmentRequest$outboundSchema: z.ZodMiniType<StopEnvironmentRequest$Outbound, StopEnvironmentRequest>;
+export declare function stopEnvironmentRequestToJSON(stopEnvironmentRequest: StopEnvironmentRequest): string;
+/** @internal */
+export declare const StopEnvironmentResponse$inboundSchema: z.ZodMiniType<StopEnvironmentResponse, unknown>;
+export declare function stopEnvironmentResponseFromJSON(jsonString: string): SafeParseResult<StopEnvironmentResponse, SDKValidationError>;

package/esm/models/operations/stop-environment.js

@@ -0,0 +1,20 @@
+/*
+ * 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 models from "../index.js";
+/** @internal */
+export const StopEnvironmentRequest$outboundSchema = z.object({
+    environmentId: z.string(),
+});
+export function stopEnvironmentRequestToJSON(stopEnvironmentRequest) {
+    return JSON.stringify(StopEnvironmentRequest$outboundSchema.parse(stopEnvironmentRequest));
+}
+/** @internal */
+export const StopEnvironmentResponse$inboundSchema = z.object({
+    data: models.Environment$inboundSchema,
+});
+export function stopEnvironmentResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => StopEnvironmentResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'StopEnvironmentResponse' from JSON`);
+}

package/esm/models/release-actor.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export type ReleaseActor = {
+    id: string;
+    name: string;
+    summary: string;
+};
+/** @internal */
+export declare const ReleaseActor$inboundSchema: z.ZodMiniType<ReleaseActor, unknown>;
+export declare function releaseActorFromJSON(jsonString: string): SafeParseResult<ReleaseActor, SDKValidationError>;

package/esm/models/release-actor.js

@@ -0,0 +1,15 @@
+/*
+ * 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 types from "../types/primitives.js";
+/** @internal */
+export const ReleaseActor$inboundSchema = z.object({
+    id: types.string(),
+    name: types.string(),
+    summary: types.string(),
+});
+export function releaseActorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ReleaseActor$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ReleaseActor' from JSON`);
+}

package/esm/models/release.d.ts

@@ -0,0 +1,26 @@
+import * as z from "zod/v4-mini";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ApiProfile } from "./api-profile.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import { ReleaseActor } from "./release-actor.js";
+export declare const Qualification: {
+    readonly Development: "development";
+    readonly Qualified: "qualified";
+};
+export type Qualification = OpenEnum<typeof Qualification>;
+export type Release = {
+    actors: Array<ReleaseActor>;
+    apis: Array<ApiProfile>;
+    appId: string;
+    createdAt: Date;
+    id: string;
+    qualification: Qualification;
+    retiredAt: Date | null;
+    version: string;
+};
+/** @internal */
+export declare const Qualification$inboundSchema: z.ZodMiniType<Qualification, unknown>;
+/** @internal */
+export declare const Release$inboundSchema: z.ZodMiniType<Release, unknown>;
+export declare function releaseFromJSON(jsonString: string): SafeParseResult<Release, SDKValidationError>;

package/esm/models/release.js

@@ -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 * as openEnums from "../types/enums.js";
+import * as types from "../types/primitives.js";
+import { ApiProfile$inboundSchema } from "./api-profile.js";
+import { ReleaseActor$inboundSchema } from "./release-actor.js";
+export const Qualification = {
+    Development: "development",
+    Qualified: "qualified",
+};
+/** @internal */
+export const Qualification$inboundSchema = openEnums.inboundSchema(Qualification);
+/** @internal */
+export const Release$inboundSchema = z.object({
+    actors: z.array(ReleaseActor$inboundSchema),
+    apis: z.array(ApiProfile$inboundSchema),
+    appId: types.string(),
+    createdAt: types.date(),
+    id: types.string(),
+    qualification: Qualification$inboundSchema,
+    retiredAt: types.nullable(types.date()),
+    version: types.string(),
+});
+export function releaseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Release$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Release' from JSON`);
+}

package/esm/models/security.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod/v4-mini";
+export type Security = {
+    apiKey: string;
+};
+/** @internal */
+export type Security$Outbound = {
+    apiKey: string;
+};
+/** @internal */
+export declare const Security$outboundSchema: z.ZodMiniType<Security$Outbound, Security>;
+export declare function securityToJSON(security: Security): string;

package/esm/models/security.js

@@ -0,0 +1,11 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+/** @internal */
+export const Security$outboundSchema = z.object({
+    apiKey: z.string(),
+});
+export function securityToJSON(security) {
+    return JSON.stringify(Security$outboundSchema.parse(security));
+}

package/esm/models/workspace.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { Actor } from "./actor.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export type Workspace = {
+    archivedAt: Date | null;
+    createdAt: Date;
+    createdBy: Actor | null;
+    id: string;
+    name: string;
+    updatedAt: Date;
+    version: number;
+};
+/** @internal */
+export declare const Workspace$inboundSchema: z.ZodMiniType<Workspace, unknown>;
+export declare function workspaceFromJSON(jsonString: string): SafeParseResult<Workspace, SDKValidationError>;

package/esm/models/workspace.js

@@ -0,0 +1,21 @@
+/*
+ * 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 types from "../types/primitives.js";
+import { Actor$inboundSchema } from "./actor.js";
+/** @internal */
+export const Workspace$inboundSchema = z
+    .object({
+    archivedAt: types.nullable(types.date()),
+    createdAt: types.date(),
+    createdBy: types.nullable(Actor$inboundSchema),
+    id: types.string(),
+    name: types.string(),
+    updatedAt: types.date(),
+    version: types.number(),
+});
+export function workspaceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Workspace$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Workspace' from JSON`);
+}

package/esm/sdk/catalog.d.ts

@@ -0,0 +1,6 @@
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+export declare class Catalog extends ClientSDK {
+    get(options?: RequestOptions): Promise<operations.GetCatalogResponse>;
+    release(request: operations.GetReleaseRequest, options?: RequestOptions): Promise<operations.GetReleaseResponse>;
+}

package/esm/sdk/catalog.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { catalogGet } from "../funcs/catalog-get.js";
+import { catalogRelease } from "../funcs/catalog-release.js";
+import { ClientSDK } from "../lib/sdks.js";
+import { unwrapAsync } from "../types/fp.js";
+export class Catalog extends ClientSDK {
+    async get(options) {
+        return unwrapAsync(catalogGet(this, options));
+    }
+    async release(request, options) {
+        return unwrapAsync(catalogRelease(this, request, options));
+    }
+}

package/esm/sdk/credential.d.ts

@@ -0,0 +1,5 @@
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+export declare class Credential extends ClientSDK {
+    get(options?: RequestOptions): Promise<operations.GetCredentialResponse>;
+}

package/esm/sdk/credential.js

@@ -0,0 +1,11 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { credentialGet } from "../funcs/credential-get.js";
+import { ClientSDK } from "../lib/sdks.js";
+import { unwrapAsync } from "../types/fp.js";
+export class Credential extends ClientSDK {
+    async get(options) {
+        return unwrapAsync(credentialGet(this, options));
+    }
+}

package/esm/sdk/environments.d.ts

@@ -0,0 +1,12 @@
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+export declare class Environments extends ClientSDK {
+    get(request: operations.GetEnvironmentRequest, options?: RequestOptions): Promise<operations.GetEnvironmentResponse>;
+    getConnection(request: operations.GetConnectionRequest, options?: RequestOptions): Promise<operations.GetConnectionResponse>;
+    reveal(request: operations.RevealConnectionRequest, options?: RequestOptions): Promise<operations.RevealConnectionResponse>;
+    events(request: operations.ListEnvironmentEventsRequest, options?: RequestOptions): Promise<models.EventPage>;
+    stop(request: operations.StopEnvironmentRequest, options?: RequestOptions): Promise<operations.StopEnvironmentResponse>;
+    list(request: operations.ListEnvironmentsRequest, options?: RequestOptions): Promise<operations.ListEnvironmentsResponse>;
+    create(request: operations.CreateEnvironmentsRequest, options?: RequestOptions): Promise<operations.CreateEnvironmentsResponse>;
+}

package/esm/sdk/environments.js

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { environmentsCreate } from "../funcs/environments-create.js";
+import { environmentsEvents } from "../funcs/environments-events.js";
+import { environmentsGetConnection } from "../funcs/environments-get-connection.js";
+import { environmentsGet } from "../funcs/environments-get.js";
+import { environmentsList } from "../funcs/environments-list.js";
+import { environmentsReveal } from "../funcs/environments-reveal.js";
+import { environmentsStop } from "../funcs/environments-stop.js";
+import { ClientSDK } from "../lib/sdks.js";
+import { unwrapAsync } from "../types/fp.js";
+export class Environments extends ClientSDK {
+    async get(request, options) {
+        return unwrapAsync(environmentsGet(this, request, options));
+    }
+    async getConnection(request, options) {
+        return unwrapAsync(environmentsGetConnection(this, request, options));
+    }
+    async reveal(request, options) {
+        return unwrapAsync(environmentsReveal(this, request, options));
+    }
+    async events(request, options) {
+        return unwrapAsync(environmentsEvents(this, request, options));
+    }
+    async stop(request, options) {
+        return unwrapAsync(environmentsStop(this, request, options));
+    }
+    async list(request, options) {
+        return unwrapAsync(environmentsList(this, request, options));
+    }
+    async create(request, options) {
+        return unwrapAsync(environmentsCreate(this, request, options));
+    }
+}

package/esm/sdk/index.d.ts

@@ -0,0 +1 @@
+export * from "./sdk.js";

package/esm/sdk/index.js

@@ -0,0 +1,4 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+export * from "./sdk.js";

package/esm/sdk/sdk.d.ts

@@ -0,0 +1,15 @@
+import { ClientSDK } from "../lib/sdks.js";
+import { Catalog } from "./catalog.js";
+import { Credential } from "./credential.js";
+import { Environments } from "./environments.js";
+import { Workspaces } from "./workspaces.js";
+export declare class StateMachines extends ClientSDK {
+    private _catalog?;
+    get catalog(): Catalog;
+    private _credential?;
+    get credential(): Credential;
+    private _environments?;
+    get environments(): Environments;
+    private _workspaces?;
+    get workspaces(): Workspaces;
+}

package/esm/sdk/sdk.js

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { ClientSDK } from "../lib/sdks.js";
+import { Catalog } from "./catalog.js";
+import { Credential } from "./credential.js";
+import { Environments } from "./environments.js";
+import { Workspaces } from "./workspaces.js";
+export class StateMachines extends ClientSDK {
+    _catalog;
+    get catalog() {
+        return (this._catalog ?? (this._catalog = new Catalog(this._options)));
+    }
+    _credential;
+    get credential() {
+        return (this._credential ?? (this._credential = new Credential(this._options)));
+    }
+    _environments;
+    get environments() {
+        return (this._environments ?? (this._environments = new Environments(this._options)));
+    }
+    _workspaces;
+    get workspaces() {
+        return (this._workspaces ?? (this._workspaces = new Workspaces(this._options)));
+    }
+}

package/esm/sdk/workspaces.d.ts

@@ -0,0 +1,8 @@
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+export declare class Workspaces extends ClientSDK {
+    list(request?: operations.ListWorkspacesRequest | undefined, options?: RequestOptions): Promise<operations.ListWorkspacesResponse>;
+    get(request: operations.GetWorkspaceRequest, options?: RequestOptions): Promise<operations.GetWorkspaceResponse>;
+    events(request: operations.ListWorkspaceEventsRequest, options?: RequestOptions): Promise<models.EventPage>;
+}

package/esm/sdk/workspaces.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { workspacesEvents } from "../funcs/workspaces-events.js";
+import { workspacesGet } from "../funcs/workspaces-get.js";
+import { workspacesList } from "../funcs/workspaces-list.js";
+import { ClientSDK } from "../lib/sdks.js";
+import { unwrapAsync } from "../types/fp.js";
+export class Workspaces extends ClientSDK {
+    async list(request, options) {
+        return unwrapAsync(workspacesList(this, request, options));
+    }
+    async get(request, options) {
+        return unwrapAsync(workspacesGet(this, request, options));
+    }
+    async events(request, options) {
+        return unwrapAsync(workspacesEvents(this, request, options));
+    }
+}

package/esm/types/async.d.ts

@@ -0,0 +1,22 @@
+export type APICall = {
+    status: "complete";
+    request: Request;
+    response: Response;
+} | {
+    status: "request-error";
+    request: Request;
+    response?: undefined;
+} | {
+    status: "invalid";
+    request?: undefined;
+    response?: undefined;
+};
+export declare class APIPromise<T> implements Promise<T> {
+    #private;
+    readonly [Symbol.toStringTag] = "APIPromise";
+    constructor(p: [T, APICall] | Promise<[T, APICall]>);
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null | undefined): Promise<T>;
+    $inspect(): Promise<[T, APICall]>;
+}

package/esm/types/async.js

@@ -0,0 +1,27 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+export class APIPromise {
+    #promise;
+    #unwrapped;
+    [Symbol.toStringTag] = "APIPromise";
+    constructor(p) {
+        this.#promise = p instanceof Promise ? p : Promise.resolve(p);
+        this.#unwrapped = p instanceof Promise ? null : Promise.resolve(p[0]);
+    }
+    #getUnwrapped() {
+        return (this.#unwrapped ?? (this.#unwrapped = this.#promise.then(([value]) => value)));
+    }
+    then(onfulfilled, onrejected) {
+        return this.#promise.then(onfulfilled ? ([value]) => onfulfilled(value) : void 0, onrejected);
+    }
+    catch(onrejected) {
+        return this.#getUnwrapped().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.#getUnwrapped().finally(onfinally);
+    }
+    $inspect() {
+        return this.#promise;
+    }
+}

package/esm/types/blobs.d.ts

@@ -0,0 +1,3 @@
+import * as z from "zod/v4-mini";
+export declare const blobLikeSchema: z.ZodMiniType<Blob, Blob>;
+export declare function isBlobLike(val: unknown): val is Blob;

package/esm/types/blobs.js

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+export const blobLikeSchema = z.custom(isBlobLike, {
+    message: "expected a Blob, File or Blob-like object",
+    abort: true,
+});
+export function isBlobLike(val) {
+    if (val instanceof Blob) {
+        return true;
+    }
+    if (typeof val !== "object" || val == null || !(Symbol.toStringTag in val)) {
+        return false;
+    }
+    const name = val[Symbol.toStringTag];
+    if (typeof name !== "string") {
+        return false;
+    }
+    if (name !== "Blob" && name !== "File") {
+        return false;
+    }
+    return "stream" in val && typeof val.stream === "function";
+}

package/esm/types/const-date-time.d.ts

@@ -0,0 +1,2 @@
+import * as z from "zod/v4-mini";
+export declare function constDateTime(val: string): z.ZodMiniType<string, unknown>;

package/esm/types/const-date-time.js

@@ -0,0 +1,9 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+export function constDateTime(val) {
+    return z.custom((v) => {
+        return (typeof v === "string" && new Date(v).getTime() === new Date(val).getTime());
+    }, `Value must be equivalent to ${val}`);
+}

package/esm/types/default-to-zero-value.d.ts

@@ -0,0 +1,11 @@
+import { type Unrecognized } from "./unrecognized.js";
+export declare function defaultToZeroValue<T>(value: T): Unrecognized<T>;
+export declare function startCountingDefaultToZeroValue(): {
+    /**
+     * Ends counting and returns the delta.
+     * @param delta - If provided, only this amount is added to the parent counter
+     *   (used for nested unions where we only want to record the winning option's count).
+     *   If not provided, records all counts since start().
+     */
+    end: (delta?: number | undefined) => number;
+};

package/esm/types/default-to-zero-value.js

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { unrecognized } from "./unrecognized.js";
+let globalCount = 0;
+let refCount = 0;
+export function defaultToZeroValue(value) {
+    globalCount++;
+    return unrecognized(value);
+}
+export function startCountingDefaultToZeroValue() {
+    refCount++;
+    const start = globalCount;
+    return {
+        /**
+         * Ends counting and returns the delta.
+         * @param delta - If provided, only this amount is added to the parent counter
+         *   (used for nested unions where we only want to record the winning option's count).
+         *   If not provided, records all counts since start().
+         */
+        end: (delta) => {
+            const count = globalCount - start;
+            // Reset globalCount back to start, then add only the specified delta
+            globalCount = start + (delta ?? count);
+            if (--refCount === 0)
+                globalCount = 0;
+            return count;
+        },
+    };
+}