@distilled.cloud/workos 0.0.0 → 0.15.1

package/src/operations/ApplicationCredentialsControllerCreate.ts

@@ -0,0 +1,47 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { NotFound, UnprocessableEntity } from "../errors.ts";
+import { SensitiveString } from "../sensitive.ts";
+
+// Input Schema
+export const ApplicationCredentialsControllerCreateInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/connect/applications/{id}/client_secrets",
+    }),
+  );
+export type ApplicationCredentialsControllerCreateInput =
+  typeof ApplicationCredentialsControllerCreateInput.Type;
+
+// Output Schema
+export const ApplicationCredentialsControllerCreateOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    id: Schema.String,
+    secret_hint: Schema.String,
+    last_used_at: Schema.NullOr(Schema.String),
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    secret: SensitiveString,
+  });
+export type ApplicationCredentialsControllerCreateOutput =
+  typeof ApplicationCredentialsControllerCreateOutput.Type;
+
+// The operation
+/**
+ * Create a new client secret for a Connect Application
+ *
+ * Create new secrets for a Connect Application.
+ *
+ * @param id - The application ID or client ID of the Connect Application.
+ */
+export const ApplicationCredentialsControllerCreate =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: ApplicationCredentialsControllerCreateInput,
+    outputSchema: ApplicationCredentialsControllerCreateOutput,
+    errors: [NotFound, UnprocessableEntity] as const,
+  }));

package/src/operations/ApplicationCredentialsControllerDelete.ts

@@ -0,0 +1,33 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { NotFound } from "../errors.ts";
+
+// Input Schema
+export const ApplicationCredentialsControllerDeleteInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "DELETE", path: "/connect/client_secrets/{id}" }));
+export type ApplicationCredentialsControllerDeleteInput =
+  typeof ApplicationCredentialsControllerDeleteInput.Type;
+
+// Output Schema
+export const ApplicationCredentialsControllerDeleteOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type ApplicationCredentialsControllerDeleteOutput =
+  typeof ApplicationCredentialsControllerDeleteOutput.Type;
+
+// The operation
+/**
+ * Delete a Client Secret
+ *
+ * Delete (revoke) an existing client secret.
+ *
+ * @param id - The unique ID of the client secret.
+ */
+export const ApplicationCredentialsControllerDelete =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: ApplicationCredentialsControllerDeleteInput,
+    outputSchema: ApplicationCredentialsControllerDeleteOutput,
+    errors: [NotFound] as const,
+  }));

package/src/operations/ApplicationCredentialsControllerList.ts

@@ -0,0 +1,47 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { NotFound } from "../errors.ts";
+
+// Input Schema
+export const ApplicationCredentialsControllerListInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/connect/applications/{id}/client_secrets",
+    }),
+  );
+export type ApplicationCredentialsControllerListInput =
+  typeof ApplicationCredentialsControllerListInput.Type;
+
+// Output Schema
+export const ApplicationCredentialsControllerListOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
+    Schema.Struct({
+      object: Schema.String,
+      id: Schema.String,
+      secret_hint: Schema.String,
+      last_used_at: Schema.NullOr(Schema.String),
+      created_at: Schema.String,
+      updated_at: Schema.String,
+    }),
+  );
+export type ApplicationCredentialsControllerListOutput =
+  typeof ApplicationCredentialsControllerListOutput.Type;
+
+// The operation
+/**
+ * List Client Secrets for a Connect Application
+ *
+ * List all client secrets associated with a Connect Application.
+ *
+ * @param id - The application ID or client ID of the Connect Application.
+ */
+export const ApplicationCredentialsControllerList =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: ApplicationCredentialsControllerListInput,
+    outputSchema: ApplicationCredentialsControllerListOutput,
+    errors: [NotFound] as const,
+  }));

package/src/operations/ApplicationsControllerCreate.ts

@@ -0,0 +1,40 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { NotFound, UnprocessableEntity } from "../errors.ts";
+
+// Input Schema
+export const ApplicationsControllerCreateInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
+    T.Http({ method: "POST", path: "/connect/applications" }),
+  );
+export type ApplicationsControllerCreateInput =
+  typeof ApplicationsControllerCreateInput.Type;
+
+// Output Schema
+export const ApplicationsControllerCreateOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    id: Schema.String,
+    client_id: Schema.String,
+    description: Schema.NullOr(Schema.String),
+    name: Schema.String,
+    scopes: Schema.Array(Schema.String),
+    created_at: Schema.String,
+    updated_at: Schema.String,
+  });
+export type ApplicationsControllerCreateOutput =
+  typeof ApplicationsControllerCreateOutput.Type;
+
+// The operation
+/**
+ * Create a Connect Application
+ *
+ * Create a new Connect Application. Supports both OAuth and Machine-to-Machine (M2M) application types.
+ */
+export const ApplicationsControllerCreate =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: ApplicationsControllerCreateInput,
+    outputSchema: ApplicationsControllerCreateOutput,
+    errors: [NotFound, UnprocessableEntity] as const,
+  }));

package/src/operations/ApplicationsControllerDelete.ts

@@ -0,0 +1,33 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { NotFound } from "../errors.ts";
+
+// Input Schema
+export const ApplicationsControllerDeleteInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "DELETE", path: "/connect/applications/{id}" }));
+export type ApplicationsControllerDeleteInput =
+  typeof ApplicationsControllerDeleteInput.Type;
+
+// Output Schema
+export const ApplicationsControllerDeleteOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type ApplicationsControllerDeleteOutput =
+  typeof ApplicationsControllerDeleteOutput.Type;
+
+// The operation
+/**
+ * Delete a Connect Application
+ *
+ * Delete an existing Connect Application.
+ *
+ * @param id - The application ID or client ID of the Connect Application.
+ */
+export const ApplicationsControllerDelete =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: ApplicationsControllerDeleteInput,
+    outputSchema: ApplicationsControllerDeleteOutput,
+    errors: [NotFound] as const,
+  }));

package/src/operations/ApplicationsControllerFind.ts

@@ -0,0 +1,43 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { NotFound } from "../errors.ts";
+
+// Input Schema
+export const ApplicationsControllerFindInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "GET", path: "/connect/applications/{id}" }));
+export type ApplicationsControllerFindInput =
+  typeof ApplicationsControllerFindInput.Type;
+
+// Output Schema
+export const ApplicationsControllerFindOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    id: Schema.String,
+    client_id: Schema.String,
+    description: Schema.NullOr(Schema.String),
+    name: Schema.String,
+    scopes: Schema.Array(Schema.String),
+    created_at: Schema.String,
+    updated_at: Schema.String,
+  });
+export type ApplicationsControllerFindOutput =
+  typeof ApplicationsControllerFindOutput.Type;
+
+// The operation
+/**
+ * Get a Connect Application
+ *
+ * Retrieve details for a specific Connect Application by ID or client ID.
+ *
+ * @param id - The application ID or client ID of the Connect Application.
+ */
+export const ApplicationsControllerFind = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: ApplicationsControllerFindInput,
+    outputSchema: ApplicationsControllerFindOutput,
+    errors: [NotFound] as const,
+  }),
+);

package/src/operations/ApplicationsControllerList.ts

@@ -0,0 +1,60 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { UnprocessableEntity } from "../errors.ts";
+
+// Input Schema
+export const ApplicationsControllerListInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    before: Schema.optional(Schema.String),
+    after: Schema.optional(Schema.String),
+    limit: Schema.optional(Schema.Number),
+    order: Schema.optional(Schema.Literals(["normal", "desc", "asc"])),
+    organization_id: Schema.optional(Schema.String),
+  }).pipe(T.Http({ method: "GET", path: "/connect/applications" }));
+export type ApplicationsControllerListInput =
+  typeof ApplicationsControllerListInput.Type;
+
+// Output Schema
+export const ApplicationsControllerListOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    data: Schema.Array(
+      Schema.Struct({
+        object: Schema.String,
+        id: Schema.String,
+        client_id: Schema.String,
+        description: Schema.NullOr(Schema.String),
+        name: Schema.String,
+        scopes: Schema.Array(Schema.String),
+        created_at: Schema.String,
+        updated_at: Schema.String,
+      }),
+    ),
+    list_metadata: Schema.Struct({
+      before: Schema.NullOr(Schema.String),
+      after: Schema.NullOr(Schema.String),
+    }),
+  });
+export type ApplicationsControllerListOutput =
+  typeof ApplicationsControllerListOutput.Type;
+
+// The operation
+/**
+ * List Connect Applications
+ *
+ * List all Connect Applications in the current environment with optional filtering.
+ *
+ * @param before - An object ID that defines your place in the list. When the ID is not present, you are at the end of the list. For example, if you make a list request and receive 100 objects, ending with `"obj_123"`, your subsequent call can include `before="obj_123"` to fetch a new batch of objects before `"obj_123"`.
+ * @param after - An object ID that defines your place in the list. When the ID is not present, you are at the end of the list. For example, if you make a list request and receive 100 objects, ending with `"obj_123"`, your subsequent call can include `after="obj_123"` to fetch a new batch of objects after `"obj_123"`.
+ * @param limit - Upper limit on the number of objects to return, between `1` and `100`.
+ * @param order - Order the results by the creation time. Supported values are `"asc"` (ascending), `"desc"` (descending), and `"normal"` (descending with reversed cursor semantics where `before` fetches older records and `after` fetches newer records). Defaults to descending.
+ * @param organization_id - Filter Connect Applications by organization ID.
+ */
+export const ApplicationsControllerList = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: ApplicationsControllerListInput,
+    outputSchema: ApplicationsControllerListOutput,
+    errors: [UnprocessableEntity] as const,
+  }),
+);

package/src/operations/ApplicationsControllerUpdate.ts

@@ -0,0 +1,55 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { NotFound, UnprocessableEntity } from "../errors.ts";
+
+// Input Schema
+export const ApplicationsControllerUpdateInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+    name: Schema.optional(Schema.String),
+    description: Schema.optional(Schema.NullOr(Schema.String)),
+    scopes: Schema.optional(Schema.NullOr(Schema.Array(Schema.String))),
+    redirect_uris: Schema.optional(
+      Schema.NullOr(
+        Schema.Array(
+          Schema.Struct({
+            uri: Schema.String,
+            default: Schema.optional(Schema.NullOr(Schema.Boolean)),
+          }),
+        ),
+      ),
+    ),
+  }).pipe(T.Http({ method: "PUT", path: "/connect/applications/{id}" }));
+export type ApplicationsControllerUpdateInput =
+  typeof ApplicationsControllerUpdateInput.Type;
+
+// Output Schema
+export const ApplicationsControllerUpdateOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    id: Schema.String,
+    client_id: Schema.String,
+    description: Schema.NullOr(Schema.String),
+    name: Schema.String,
+    scopes: Schema.Array(Schema.String),
+    created_at: Schema.String,
+    updated_at: Schema.String,
+  });
+export type ApplicationsControllerUpdateOutput =
+  typeof ApplicationsControllerUpdateOutput.Type;
+
+// The operation
+/**
+ * Update a Connect Application
+ *
+ * Update an existing Connect Application. For OAuth applications, you can update redirect URIs. For all applications, you can update the name, description, and scopes.
+ *
+ * @param id - The application ID or client ID of the Connect Application.
+ */
+export const ApplicationsControllerUpdate =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: ApplicationsControllerUpdateInput,
+    outputSchema: ApplicationsControllerUpdateOutput,
+    errors: [NotFound, UnprocessableEntity] as const,
+  }));

package/src/operations/AuditLogEventsControllerCreate.ts

@@ -0,0 +1,62 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { BadRequest, NotFound, UnprocessableEntity } from "../errors.ts";
+
+// Input Schema
+export const AuditLogEventsControllerCreateInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    organization_id: Schema.String,
+    event: Schema.Struct({
+      action: Schema.String,
+      occurred_at: Schema.String,
+      actor: Schema.Struct({
+        id: Schema.String,
+        type: Schema.String,
+        name: Schema.optional(Schema.String),
+        metadata: Schema.optional(Schema.Unknown),
+      }),
+      targets: Schema.Array(
+        Schema.Struct({
+          id: Schema.String,
+          type: Schema.String,
+          name: Schema.optional(Schema.String),
+          metadata: Schema.optional(Schema.Unknown),
+        }),
+      ),
+      context: Schema.Struct({
+        location: Schema.String,
+        user_agent: Schema.optional(Schema.String),
+      }),
+      metadata: Schema.optional(Schema.Unknown),
+      version: Schema.optional(Schema.Number),
+    }),
+  }).pipe(T.Http({ method: "POST", path: "/audit_logs/events" }));
+export type AuditLogEventsControllerCreateInput =
+  typeof AuditLogEventsControllerCreateInput.Type;
+
+// Output Schema
+export const AuditLogEventsControllerCreateOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    success: Schema.Boolean,
+  });
+export type AuditLogEventsControllerCreateOutput =
+  typeof AuditLogEventsControllerCreateOutput.Type;
+
+// The operation
+/**
+ * Create Event
+ *
+ * Create an Audit Log Event.
+ * This API supports idempotency which guarantees that performing the same operation multiple times will have the same result as if the operation were performed only once. This is handy in situations where you may need to retry a request due to a failure or prevent accidental duplicate requests from creating more than one resource.
+ * To achieve idempotency, you can add `Idempotency-Key` request header to a Create Event request with a unique string as the value. Each subsequent request matching this unique string will return the same response. We suggest using [v4 UUIDs](https://en.wikipedia.org/wiki/Universally_unique_identifier) for idempotency keys to avoid collisions.
+ * Idempotency keys expire after 24 hours. The API will generate a new response if you submit a request with an expired key.
+ *
+ * @param idempotency-key - A unique string to prevent duplicate requests. Each subsequent request matching this unique string will return the same response. We suggest using v4 UUIDs. Keys expire after 24 hours.
+ */
+export const AuditLogEventsControllerCreate =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: AuditLogEventsControllerCreateInput,
+    outputSchema: AuditLogEventsControllerCreateOutput,
+    errors: [BadRequest, NotFound, UnprocessableEntity] as const,
+  }));

package/src/operations/AuditLogExportsControllerExport.ts

@@ -0,0 +1,42 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { NotFound } from "../errors.ts";
+
+// Input Schema
+export const AuditLogExportsControllerExportInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    auditLogExportId: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({ method: "GET", path: "/audit_logs/exports/{auditLogExportId}" }),
+  );
+export type AuditLogExportsControllerExportInput =
+  typeof AuditLogExportsControllerExportInput.Type;
+
+// Output Schema
+export const AuditLogExportsControllerExportOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    id: Schema.String,
+    state: Schema.Literals(["pending", "ready", "error"]),
+    url: Schema.optional(Schema.NullOr(Schema.String)),
+    created_at: Schema.String,
+    updated_at: Schema.String,
+  });
+export type AuditLogExportsControllerExportOutput =
+  typeof AuditLogExportsControllerExportOutput.Type;
+
+// The operation
+/**
+ * Get Export
+ *
+ * Get an Audit Log Export. The URL will expire after 10 minutes. If the export is needed again at a later time, refetching the export will regenerate the URL.
+ *
+ * @param auditLogExportId - The unique ID of the Audit Log Export.
+ */
+export const AuditLogExportsControllerExport =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: AuditLogExportsControllerExportInput,
+    outputSchema: AuditLogExportsControllerExportOutput,
+    errors: [NotFound] as const,
+  }));

package/src/operations/AuditLogExportsControllerExports.ts

@@ -0,0 +1,45 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { BadRequest, NotFound } from "../errors.ts";
+
+// Input Schema
+export const AuditLogExportsControllerExportsInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    organization_id: Schema.String,
+    range_start: Schema.String,
+    range_end: Schema.String,
+    actions: Schema.optional(Schema.Array(Schema.String)),
+    actors: Schema.optional(Schema.Array(Schema.String)),
+    actor_names: Schema.optional(Schema.Array(Schema.String)),
+    actor_ids: Schema.optional(Schema.Array(Schema.String)),
+    targets: Schema.optional(Schema.Array(Schema.String)),
+  }).pipe(T.Http({ method: "POST", path: "/audit_logs/exports" }));
+export type AuditLogExportsControllerExportsInput =
+  typeof AuditLogExportsControllerExportsInput.Type;
+
+// Output Schema
+export const AuditLogExportsControllerExportsOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    id: Schema.String,
+    state: Schema.Literals(["pending", "ready", "error"]),
+    url: Schema.optional(Schema.NullOr(Schema.String)),
+    created_at: Schema.String,
+    updated_at: Schema.String,
+  });
+export type AuditLogExportsControllerExportsOutput =
+  typeof AuditLogExportsControllerExportsOutput.Type;
+
+// The operation
+/**
+ * Create Export
+ *
+ * Create an Audit Log Export. Exports are scoped to a single organization within a specified date range.
+ */
+export const AuditLogExportsControllerExports =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: AuditLogExportsControllerExportsInput,
+    outputSchema: AuditLogExportsControllerExportsOutput,
+    errors: [BadRequest, NotFound] as const,
+  }));

package/src/operations/AuditLogValidatorVersionsControllerCreate.ts

@@ -0,0 +1,66 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { UnprocessableEntity } from "../errors.ts";
+
+// Input Schema
+export const AuditLogValidatorVersionsControllerCreateInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    actionName: Schema.String.pipe(T.PathParam()),
+    actor: Schema.optional(
+      Schema.Struct({
+        metadata: Schema.Unknown,
+      }),
+    ),
+    targets: Schema.Array(
+      Schema.Struct({
+        type: Schema.String,
+        metadata: Schema.optional(Schema.Unknown),
+      }),
+    ),
+    metadata: Schema.optional(Schema.Unknown),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/audit_logs/actions/{actionName}/schemas",
+    }),
+  );
+export type AuditLogValidatorVersionsControllerCreateInput =
+  typeof AuditLogValidatorVersionsControllerCreateInput.Type;
+
+// Output Schema
+export const AuditLogValidatorVersionsControllerCreateOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    version: Schema.Number,
+    actor: Schema.optional(
+      Schema.Struct({
+        metadata: Schema.Record(Schema.String, Schema.Unknown),
+      }),
+    ),
+    targets: Schema.Array(
+      Schema.Struct({
+        type: Schema.String,
+        metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+      }),
+    ),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    created_at: Schema.String,
+  });
+export type AuditLogValidatorVersionsControllerCreateOutput =
+  typeof AuditLogValidatorVersionsControllerCreateOutput.Type;
+
+// The operation
+/**
+ * Create Schema
+ *
+ * Creates a new Audit Log schema used to validate the payload of incoming Audit Log Events. If the `action` does not exist, it will also be created.
+ *
+ * @param actionName - The name of the Audit Log action.
+ */
+export const AuditLogValidatorVersionsControllerCreate =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: AuditLogValidatorVersionsControllerCreateInput,
+    outputSchema: AuditLogValidatorVersionsControllerCreateOutput,
+    errors: [UnprocessableEntity] as const,
+  }));

package/src/operations/AuditLogValidatorVersionsControllerSchemas.ts

@@ -0,0 +1,76 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { NotFound, UnprocessableEntity } from "../errors.ts";
+
+// Input Schema
+export const AuditLogValidatorVersionsControllerSchemasInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    actionName: Schema.String.pipe(T.PathParam()),
+    before: Schema.optional(Schema.String),
+    after: Schema.optional(Schema.String),
+    limit: Schema.optional(Schema.Number),
+    order: Schema.optional(Schema.Literals(["normal", "desc", "asc"])),
+  }).pipe(
+    T.Http({ method: "GET", path: "/audit_logs/actions/{actionName}/schemas" }),
+  );
+export type AuditLogValidatorVersionsControllerSchemasInput =
+  typeof AuditLogValidatorVersionsControllerSchemasInput.Type;
+
+// Output Schema
+export const AuditLogValidatorVersionsControllerSchemasOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.optional(Schema.String),
+    list_metadata: Schema.optional(
+      Schema.Struct({
+        before: Schema.NullOr(Schema.String),
+        after: Schema.NullOr(Schema.String),
+      }),
+    ),
+    data: Schema.optional(
+      Schema.Array(
+        Schema.Struct({
+          object: Schema.String,
+          version: Schema.Number,
+          actor: Schema.optional(
+            Schema.Struct({
+              metadata: Schema.Record(Schema.String, Schema.Unknown),
+            }),
+          ),
+          targets: Schema.Array(
+            Schema.Struct({
+              type: Schema.String,
+              metadata: Schema.optional(
+                Schema.Record(Schema.String, Schema.Unknown),
+              ),
+            }),
+          ),
+          metadata: Schema.optional(
+            Schema.Record(Schema.String, Schema.Unknown),
+          ),
+          created_at: Schema.String,
+        }),
+      ),
+    ),
+  });
+export type AuditLogValidatorVersionsControllerSchemasOutput =
+  typeof AuditLogValidatorVersionsControllerSchemasOutput.Type;
+
+// The operation
+/**
+ * List Schemas
+ *
+ * Get a list of all schemas for the Audit Logs action identified by `:name`.
+ *
+ * @param actionName - The name of the Audit Log action.
+ * @param before - An object ID that defines your place in the list. When the ID is not present, you are at the end of the list.
+ * @param after - An object ID that defines your place in the list. When the ID is not present, you are at the end of the list.
+ * @param limit - Upper limit on the number of objects to return, between `1` and `100`.
+ * @param order - Order the results by the creation time.
+ */
+export const AuditLogValidatorVersionsControllerSchemas =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: AuditLogValidatorVersionsControllerSchemasInput,
+    outputSchema: AuditLogValidatorVersionsControllerSchemasOutput,
+    errors: [NotFound, UnprocessableEntity] as const,
+  }));