@distilled.cloud/workos 0.0.0 → 0.15.0

package/src/operations/UserlandUserInvitesControllerGetByToken.ts

@@ -0,0 +1,54 @@
+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 UserlandUserInvitesControllerGetByTokenInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    token: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/user_management/invitations/by_token/{token}",
+    }),
+  );
+export type UserlandUserInvitesControllerGetByTokenInput =
+  typeof UserlandUserInvitesControllerGetByTokenInput.Type;
+
+// Output Schema
+export const UserlandUserInvitesControllerGetByTokenOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    id: Schema.String,
+    email: Schema.String,
+    state: Schema.Literals(["pending", "accepted", "expired", "revoked"]),
+    accepted_at: Schema.NullOr(Schema.String),
+    revoked_at: Schema.NullOr(Schema.String),
+    expires_at: Schema.String,
+    organization_id: Schema.NullOr(Schema.String),
+    inviter_user_id: Schema.NullOr(Schema.String),
+    accepted_user_id: Schema.NullOr(Schema.String),
+    role_slug: Schema.NullOr(Schema.String),
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    token: Schema.String,
+    accept_invitation_url: Schema.String,
+  });
+export type UserlandUserInvitesControllerGetByTokenOutput =
+  typeof UserlandUserInvitesControllerGetByTokenOutput.Type;
+
+// The operation
+/**
+ * Find an invitation by token
+ *
+ * Retrieve an existing invitation using the token.
+ *
+ * @param token - The token used to accept the invitation.
+ */
+export const UserlandUserInvitesControllerGetByToken =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: UserlandUserInvitesControllerGetByTokenInput,
+    outputSchema: UserlandUserInvitesControllerGetByTokenOutput,
+    errors: [NotFound] as const,
+  }));

package/src/operations/UserlandUserInvitesControllerList.ts

@@ -0,0 +1,72 @@
+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 UserlandUserInvitesControllerListInput =
+  /*@__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),
+    email: Schema.optional(Schema.String),
+  }).pipe(T.Http({ method: "GET", path: "/user_management/invitations" }));
+export type UserlandUserInvitesControllerListInput =
+  typeof UserlandUserInvitesControllerListInput.Type;
+
+// Output Schema
+export const UserlandUserInvitesControllerListOutput =
+  /*@__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,
+          id: Schema.String,
+          email: Schema.String,
+          state: Schema.Literals(["pending", "accepted", "expired", "revoked"]),
+          accepted_at: Schema.NullOr(Schema.String),
+          revoked_at: Schema.NullOr(Schema.String),
+          expires_at: Schema.String,
+          organization_id: Schema.NullOr(Schema.String),
+          inviter_user_id: Schema.NullOr(Schema.String),
+          accepted_user_id: Schema.NullOr(Schema.String),
+          role_slug: Schema.NullOr(Schema.String),
+          created_at: Schema.String,
+          updated_at: Schema.String,
+          token: Schema.String,
+          accept_invitation_url: Schema.String,
+        }),
+      ),
+    ),
+  });
+export type UserlandUserInvitesControllerListOutput =
+  typeof UserlandUserInvitesControllerListOutput.Type;
+
+// The operation
+/**
+ * List invitations
+ *
+ * Get a list of all of invitations matching the criteria specified.
+ *
+ * @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 - The ID of the [organization](/reference/organization) that the recipient will join.
+ * @param email - The email address of the recipient.
+ */
+export const UserlandUserInvitesControllerList =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: UserlandUserInvitesControllerListInput,
+    outputSchema: UserlandUserInvitesControllerListOutput,
+    errors: [UnprocessableEntity] as const,
+  }));

package/src/operations/UserlandUserInvitesControllerResend.ts

@@ -0,0 +1,148 @@
+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 UserlandUserInvitesControllerResendInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+    locale: Schema.optional(
+      Schema.Literals([
+        "af",
+        "am",
+        "ar",
+        "bg",
+        "bn",
+        "bs",
+        "ca",
+        "cs",
+        "da",
+        "de",
+        "de-DE",
+        "el",
+        "en",
+        "en-AU",
+        "en-CA",
+        "en-GB",
+        "en-US",
+        "es",
+        "es-419",
+        "es-ES",
+        "es-US",
+        "et",
+        "fa",
+        "fi",
+        "fil",
+        "fr",
+        "fr-BE",
+        "fr-CA",
+        "fr-FR",
+        "fy",
+        "gl",
+        "gu",
+        "ha",
+        "he",
+        "hi",
+        "hr",
+        "hu",
+        "hy",
+        "id",
+        "is",
+        "it",
+        "it-IT",
+        "ja",
+        "jv",
+        "ka",
+        "kk",
+        "km",
+        "kn",
+        "ko",
+        "lt",
+        "lv",
+        "mk",
+        "ml",
+        "mn",
+        "mr",
+        "ms",
+        "my",
+        "nb",
+        "ne",
+        "nl",
+        "nl-BE",
+        "nl-NL",
+        "nn",
+        "no",
+        "pa",
+        "pl",
+        "pt",
+        "pt-BR",
+        "pt-PT",
+        "ro",
+        "ru",
+        "sk",
+        "sl",
+        "sq",
+        "sr",
+        "sv",
+        "sw",
+        "ta",
+        "te",
+        "th",
+        "tr",
+        "uk",
+        "ur",
+        "uz",
+        "vi",
+        "zh",
+        "zh-CN",
+        "zh-HK",
+        "zh-TW",
+        "zu",
+      ]),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/user_management/invitations/{id}/resend",
+    }),
+  );
+export type UserlandUserInvitesControllerResendInput =
+  typeof UserlandUserInvitesControllerResendInput.Type;
+
+// Output Schema
+export const UserlandUserInvitesControllerResendOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    id: Schema.String,
+    email: Schema.String,
+    state: Schema.Literals(["pending", "accepted", "expired", "revoked"]),
+    accepted_at: Schema.NullOr(Schema.String),
+    revoked_at: Schema.NullOr(Schema.String),
+    expires_at: Schema.String,
+    organization_id: Schema.NullOr(Schema.String),
+    inviter_user_id: Schema.NullOr(Schema.String),
+    accepted_user_id: Schema.NullOr(Schema.String),
+    role_slug: Schema.NullOr(Schema.String),
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    token: Schema.String,
+    accept_invitation_url: Schema.String,
+  });
+export type UserlandUserInvitesControllerResendOutput =
+  typeof UserlandUserInvitesControllerResendOutput.Type;
+
+// The operation
+/**
+ * Resend an invitation
+ *
+ * Resends an invitation email to the recipient. The invitation must be in a pending state.
+ *
+ * @param id - The unique ID of the invitation.
+ */
+export const UserlandUserInvitesControllerResend =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: UserlandUserInvitesControllerResendInput,
+    outputSchema: UserlandUserInvitesControllerResendOutput,
+    errors: [BadRequest, NotFound, UnprocessableEntity] as const,
+  }));

package/src/operations/UserlandUserInvitesControllerRevoke.ts

@@ -0,0 +1,54 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client.ts";
+import * as T from "../traits.ts";
+import { BadRequest } from "../errors.ts";
+
+// Input Schema
+export const UserlandUserInvitesControllerRevokeInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/user_management/invitations/{id}/revoke",
+    }),
+  );
+export type UserlandUserInvitesControllerRevokeInput =
+  typeof UserlandUserInvitesControllerRevokeInput.Type;
+
+// Output Schema
+export const UserlandUserInvitesControllerRevokeOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    id: Schema.String,
+    email: Schema.String,
+    state: Schema.Literals(["pending", "accepted", "expired", "revoked"]),
+    accepted_at: Schema.NullOr(Schema.String),
+    revoked_at: Schema.NullOr(Schema.String),
+    expires_at: Schema.String,
+    organization_id: Schema.NullOr(Schema.String),
+    inviter_user_id: Schema.NullOr(Schema.String),
+    accepted_user_id: Schema.NullOr(Schema.String),
+    role_slug: Schema.NullOr(Schema.String),
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    token: Schema.String,
+    accept_invitation_url: Schema.String,
+  });
+export type UserlandUserInvitesControllerRevokeOutput =
+  typeof UserlandUserInvitesControllerRevokeOutput.Type;
+
+// The operation
+/**
+ * Revoke an invitation
+ *
+ * Revokes an existing invitation.
+ *
+ * @param id - The unique ID of the invitation.
+ */
+export const UserlandUserInvitesControllerRevoke =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: UserlandUserInvitesControllerRevokeInput,
+    outputSchema: UserlandUserInvitesControllerRevokeOutput,
+    errors: [BadRequest] as const,
+  }));

package/src/operations/UserlandUserOrganizationMembershipsControllerCreate.ts

@@ -0,0 +1,51 @@
+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 UserlandUserOrganizationMembershipsControllerCreateInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({}).pipe(
+    T.Http({
+      method: "POST",
+      path: "/user_management/organization_memberships",
+    }),
+  );
+export type UserlandUserOrganizationMembershipsControllerCreateInput =
+  typeof UserlandUserOrganizationMembershipsControllerCreateInput.Type;
+
+// Output Schema
+export const UserlandUserOrganizationMembershipsControllerCreateOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    id: Schema.String,
+    user_id: Schema.String,
+    organization_id: Schema.String,
+    status: Schema.Literals(["active", "inactive", "pending"]),
+    directory_managed: Schema.Boolean,
+    organization_name: Schema.optional(Schema.String),
+    custom_attributes: Schema.optional(
+      Schema.Record(Schema.String, Schema.Unknown),
+    ),
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    role: Schema.Struct({
+      slug: Schema.String,
+    }),
+  });
+export type UserlandUserOrganizationMembershipsControllerCreateOutput =
+  typeof UserlandUserOrganizationMembershipsControllerCreateOutput.Type;
+
+// The operation
+/**
+ * Create an organization membership
+ *
+ * Creates a new `active` organization membership for the given organization and user.
+ * Calling this API with an organization and user that match an `inactive` organization membership will activate the membership with the specified role(s).
+ */
+export const UserlandUserOrganizationMembershipsControllerCreate =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: UserlandUserOrganizationMembershipsControllerCreateInput,
+    outputSchema: UserlandUserOrganizationMembershipsControllerCreateOutput,
+    errors: [BadRequest, NotFound, UnprocessableEntity] as const,
+  }));

package/src/operations/UserlandUserOrganizationMembershipsControllerDeactivate.ts

@@ -0,0 +1,57 @@
+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 UserlandUserOrganizationMembershipsControllerDeactivateInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      path: "/user_management/organization_memberships/{id}/deactivate",
+    }),
+  );
+export type UserlandUserOrganizationMembershipsControllerDeactivateInput =
+  typeof UserlandUserOrganizationMembershipsControllerDeactivateInput.Type;
+
+// Output Schema
+export const UserlandUserOrganizationMembershipsControllerDeactivateOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    id: Schema.String,
+    user_id: Schema.String,
+    organization_id: Schema.String,
+    status: Schema.Literals(["active", "inactive", "pending"]),
+    directory_managed: Schema.Boolean,
+    organization_name: Schema.optional(Schema.String),
+    custom_attributes: Schema.optional(
+      Schema.Record(Schema.String, Schema.Unknown),
+    ),
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    role: Schema.Struct({
+      slug: Schema.String,
+    }),
+  });
+export type UserlandUserOrganizationMembershipsControllerDeactivateOutput =
+  typeof UserlandUserOrganizationMembershipsControllerDeactivateOutput.Type;
+
+// The operation
+/**
+ * Deactivate an organization membership
+ *
+ * Deactivates an `active` organization membership. Emits an [organization_membership.updated](/events/organization-membership) event upon successful deactivation.
+ * - Deactivating an `inactive` membership is a no-op and does not emit an event.
+ * - Deactivating a `pending` membership returns an error. This membership should be [deleted](/reference/authkit/organization-membership/delete) instead.
+ * See the [membership management documentation](/authkit/users-organizations/organizations/membership-management) for additional details.
+ *
+ * @param id - The unique ID of the organization membership.
+ */
+export const UserlandUserOrganizationMembershipsControllerDeactivate =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: UserlandUserOrganizationMembershipsControllerDeactivateInput,
+    outputSchema: UserlandUserOrganizationMembershipsControllerDeactivateOutput,
+    errors: [BadRequest, NotFound, UnprocessableEntity] as const,
+  }));

package/src/operations/UserlandUserOrganizationMembershipsControllerDelete.ts

@@ -0,0 +1,38 @@
+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 UserlandUserOrganizationMembershipsControllerDeleteInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      path: "/user_management/organization_memberships/{id}",
+    }),
+  );
+export type UserlandUserOrganizationMembershipsControllerDeleteInput =
+  typeof UserlandUserOrganizationMembershipsControllerDeleteInput.Type;
+
+// Output Schema
+export const UserlandUserOrganizationMembershipsControllerDeleteOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type UserlandUserOrganizationMembershipsControllerDeleteOutput =
+  typeof UserlandUserOrganizationMembershipsControllerDeleteOutput.Type;
+
+// The operation
+/**
+ * Delete an organization membership
+ *
+ * Permanently deletes an existing organization membership. It cannot be undone.
+ *
+ * @param id - The unique ID of the organization membership.
+ */
+export const UserlandUserOrganizationMembershipsControllerDelete =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: UserlandUserOrganizationMembershipsControllerDeleteInput,
+    outputSchema: UserlandUserOrganizationMembershipsControllerDeleteOutput,
+    errors: [NotFound] as const,
+  }));

package/src/operations/UserlandUserOrganizationMembershipsControllerGet.ts

@@ -0,0 +1,54 @@
+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 UserlandUserOrganizationMembershipsControllerGetInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/user_management/organization_memberships/{id}",
+    }),
+  );
+export type UserlandUserOrganizationMembershipsControllerGetInput =
+  typeof UserlandUserOrganizationMembershipsControllerGetInput.Type;
+
+// Output Schema
+export const UserlandUserOrganizationMembershipsControllerGetOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    id: Schema.String,
+    user_id: Schema.String,
+    organization_id: Schema.String,
+    status: Schema.Literals(["active", "inactive", "pending"]),
+    directory_managed: Schema.Boolean,
+    organization_name: Schema.optional(Schema.String),
+    custom_attributes: Schema.optional(
+      Schema.Record(Schema.String, Schema.Unknown),
+    ),
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    role: Schema.Struct({
+      slug: Schema.String,
+    }),
+  });
+export type UserlandUserOrganizationMembershipsControllerGetOutput =
+  typeof UserlandUserOrganizationMembershipsControllerGetOutput.Type;
+
+// The operation
+/**
+ * Get an organization membership
+ *
+ * Get the details of an existing organization membership.
+ *
+ * @param id - The unique ID of the organization membership.
+ */
+export const UserlandUserOrganizationMembershipsControllerGet =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: UserlandUserOrganizationMembershipsControllerGetInput,
+    outputSchema: UserlandUserOrganizationMembershipsControllerGetOutput,
+    errors: [NotFound] as const,
+  }));

package/src/operations/UserlandUserOrganizationMembershipsControllerList.ts

@@ -0,0 +1,79 @@
+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 UserlandUserOrganizationMembershipsControllerListInput =
+  /*@__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),
+    statuses: Schema.optional(Schema.String),
+    user_id: Schema.optional(Schema.String),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/user_management/organization_memberships",
+    }),
+  );
+export type UserlandUserOrganizationMembershipsControllerListInput =
+  typeof UserlandUserOrganizationMembershipsControllerListInput.Type;
+
+// Output Schema
+export const UserlandUserOrganizationMembershipsControllerListOutput =
+  /*@__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,
+          id: Schema.String,
+          user_id: Schema.String,
+          organization_id: Schema.String,
+          status: Schema.Literals(["active", "inactive", "pending"]),
+          directory_managed: Schema.Boolean,
+          organization_name: Schema.optional(Schema.String),
+          custom_attributes: Schema.optional(
+            Schema.Record(Schema.String, Schema.Unknown),
+          ),
+          created_at: Schema.String,
+          updated_at: Schema.String,
+          role: Schema.Struct({
+            slug: Schema.String,
+          }),
+        }),
+      ),
+    ),
+  });
+export type UserlandUserOrganizationMembershipsControllerListOutput =
+  typeof UserlandUserOrganizationMembershipsControllerListOutput.Type;
+
+// The operation
+/**
+ * List organization memberships
+ *
+ * Get a list of all organization memberships matching the criteria specified. At least one of `user_id` or `organization_id` must be provided. By default only active memberships are returned. Use the `statuses` parameter to filter by other statuses.
+ *
+ * @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 - The ID of the [organization](/reference/organization) which the user belongs to.
+ * @param statuses - Filter by the status of the organization membership. Array including any of `active`, `inactive`, or `pending`.
+ * @param user_id - The ID of the [user](/reference/authkit/user).
+ */
+export const UserlandUserOrganizationMembershipsControllerList =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: UserlandUserOrganizationMembershipsControllerListInput,
+    outputSchema: UserlandUserOrganizationMembershipsControllerListOutput,
+    errors: [BadRequest, NotFound, UnprocessableEntity] as const,
+  }));

package/src/operations/UserlandUserOrganizationMembershipsControllerReactivate.ts

@@ -0,0 +1,57 @@
+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 UserlandUserOrganizationMembershipsControllerReactivateInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      path: "/user_management/organization_memberships/{id}/reactivate",
+    }),
+  );
+export type UserlandUserOrganizationMembershipsControllerReactivateInput =
+  typeof UserlandUserOrganizationMembershipsControllerReactivateInput.Type;
+
+// Output Schema
+export const UserlandUserOrganizationMembershipsControllerReactivateOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    object: Schema.String,
+    id: Schema.String,
+    user_id: Schema.String,
+    organization_id: Schema.String,
+    status: Schema.Literals(["active", "inactive", "pending"]),
+    directory_managed: Schema.Boolean,
+    organization_name: Schema.optional(Schema.String),
+    custom_attributes: Schema.optional(
+      Schema.Record(Schema.String, Schema.Unknown),
+    ),
+    created_at: Schema.String,
+    updated_at: Schema.String,
+    role: Schema.Struct({
+      slug: Schema.String,
+    }),
+  });
+export type UserlandUserOrganizationMembershipsControllerReactivateOutput =
+  typeof UserlandUserOrganizationMembershipsControllerReactivateOutput.Type;
+
+// The operation
+/**
+ * Reactivate an organization membership
+ *
+ * Reactivates an `inactive` organization membership, retaining the pre-existing role(s). Emits an [organization_membership.updated](/events/organization-membership) event upon successful reactivation.
+ * - Reactivating an `active` membership is a no-op and does not emit an event.
+ * - Reactivating a `pending` membership returns an error. The user needs to [accept the invitation](/authkit/invitations) instead.
+ * See the [membership management documentation](/authkit/users-organizations/organizations/membership-management) for additional details.
+ *
+ * @param id - The unique ID of the organization membership.
+ */
+export const UserlandUserOrganizationMembershipsControllerReactivate =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: UserlandUserOrganizationMembershipsControllerReactivateInput,
+    outputSchema: UserlandUserOrganizationMembershipsControllerReactivateOutput,
+    errors: [BadRequest, NotFound, UnprocessableEntity] as const,
+  }));