@automate.ax/api-contract 0.75.0 → 0.77.0

package/dist/account.js

@@ -1,8 +1,83 @@
 import { oc } from "@orpc/contract";
-import { z } from "zod";
-export const integrationAccountOutputSchema = z.object({
+import * as z from "zod";
+import { cursorPageOutputSchema, cursorPaginationInputSchema } from "./schemas.js";
+const INTEGRATION_FORM_FIELD_SCHEMA = z.discriminatedUnion("input", [
+    z.object({
+        default: z.boolean().optional(),
+        description: z.string().optional(),
+        input: z.literal("boolean"),
+        label: z.string(),
+        name: z.string(),
+        required: z.boolean(),
+    }),
+    z.object({
+        default: z.number().optional(),
+        description: z.string().optional(),
+        input: z.literal("number"),
+        label: z.string(),
+        name: z.string(),
+        placeholder: z.string().optional(),
+        required: z.boolean(),
+    }),
+    z.object({
+        description: z.string().optional(),
+        input: z.literal("password"),
+        label: z.string(),
+        name: z.string(),
+        placeholder: z.string().optional(),
+        required: z.boolean(),
+    }),
+    z.object({
+        default: z.string().optional(),
+        description: z.string().optional(),
+        input: z.enum(["email", "text", "url"]),
+        label: z.string(),
+        name: z.string(),
+        placeholder: z.string().optional(),
+        required: z.boolean(),
+    }),
+]);
+export const integrationServiceOutputSchema = z.object({
+    connectionMethods: z
+        .discriminatedUnion("type", [
+        z.object({
+            description: z.string().optional(),
+            id: z.string(),
+            name: z.string(),
+            type: z.literal("redirect"),
+        }),
+        z.object({
+            description: z.string().optional(),
+            fields: INTEGRATION_FORM_FIELD_SCHEMA.array(),
+            id: z.string(),
+            name: z.string(),
+            type: z.literal("form"),
+        }),
+    ])
+        .array(),
+    connectionNotice: z
+        .object({
+        action: z.object({ href: z.string(), label: z.string() }),
+        description: z.string(),
+        title: z.string(),
+    })
+        .optional(),
+    description: z.string().optional(),
+    icon: z.string().optional(),
+    id: z.string(),
+    name: z.string(),
+    preferredConnectionMethodId: z.string().optional(),
+});
+export const integrationAccountRevocationOutputSchema = z.object({
+    completedAt: z.date().nullable(),
+    error: z.string().nullable(),
+    id: z.string(),
+    requestedAt: z.date(),
+    status: z.enum(["pending", "succeeded", "failed", "unsupported"]),
+});
+export const integrationAccountBindingOutputSchema = z.object({
     checkedAt: z.date().nullable(),
-    connectionId: z.string().min(1),
+    connectionMethodId: z.string().min(1),
     error: z
         .object({
         code: z.string(),
@@ -15,40 +90,196 @@ export const integrationAccountOutputSchema = z.object({
     serviceId: z.string(),
     serviceSub: z.string(),
 });
+export const integrationAccountOutputSchema = integrationAccountBindingOutputSchema.extend({
+    revokedAt: z.date().nullable(),
+    revocation: integrationAccountRevocationOutputSchema.nullable(),
+    status: z.enum([
+        "active",
+        "revocation_pending",
+        "revocation_failed",
+        "revoked",
+    ]),
+});
+export const integrationAccountRevocationImpactOutputSchema = z.object({
+    accessibleOrganizations: z
+        .object({
+        id: z.string(),
+        name: z.string(),
+        projects: z
+            .object({
+            automations: z
+                .object({
+                enabled: z.boolean(),
+                id: z.string(),
+                identityKey: z.string(),
+            })
+                .array(),
+            id: z.string(),
+            name: z.string(),
+            pendingDeployments: z
+                .object({
+                id: z.string(),
+                status: z.enum([
+                    "awaiting_authorization",
+                    "configuring",
+                    "publishing",
+                ]),
+            })
+                .array(),
+        })
+            .array(),
+    })
+        .array(),
+    account: integrationAccountOutputSchema
+        .pick({
+        id: true,
+        label: true,
+        revokedAt: true,
+        revocation: true,
+        serviceId: true,
+        serviceSub: true,
+        status: true,
+    })
+        .extend({
+        connectionMethodId: z.string(),
+        providerRevocationSupported: z.boolean(),
+    }),
+    hiddenOrganizationCount: z.number().int().nonnegative(),
+    totals: z.object({
+        automations: z.number().int().nonnegative(),
+        organizations: z.number().int().positive(),
+        pendingDeployments: z.number().int().nonnegative(),
+        projects: z.number().int().nonnegative(),
+    }),
+});
+const organizationAccountInputSchema = z.object({
+    accountId: z.string(),
+    organizationId: z.string(),
+});
 export const accountContract = {
     beginConnection: oc
+        .route({
+        description: "Starts an OAuth-style organization account connection.",
+        method: "POST",
+        operationId: "beginIntegrationAccountConnection",
+        path: "/organizations/{organizationId}/integration-account-connections",
+        successStatus: 201,
+        summary: "Begin integration account connection",
+        tags: ["Integration Accounts"],
+    })
         .input(z.object({
-        connectionId: z.string().min(1),
+        connectionMethodId: z.string().min(1),
         organizationId: z.string(),
         scopes: z.string().array().default([]),
         serviceId: z.string().min(1),
     }))
         .output(z.object({ flowId: z.string(), url: z.url() })),
     connectionStatus: oc
+        .route({
+        description: "Returns the current state of a redirect connection flow.",
+        method: "GET",
+        operationId: "getIntegrationAccountConnection",
+        path: "/organizations/{organizationId}/integration-account-connections/{flowId}",
+        summary: "Get integration account connection",
+        tags: ["Integration Accounts"],
+    })
         .input(z.object({
         flowId: z.string(),
         organizationId: z.string(),
     }))
         .output(z.discriminatedUnion("status", [
         z.object({ status: z.literal("pending") }),
-        z.object({ status: z.literal("succeeded") }),
+        z.object({
+            accountId: z.string().nullable(),
+            status: z.literal("succeeded"),
+        }),
         z.object({ message: z.string(), status: z.literal("failed") }),
     ])),
-    delete: oc
-        .input(z.object({
-        accountId: z.string(),
-        organizationId: z.string(),
-    }))
+    disconnect: oc
+        .route({
+        description: "Removes an integration account from one organization without revoking it elsewhere.",
+        method: "DELETE",
+        operationId: "disconnectIntegrationAccount",
+        path: "/organizations/{organizationId}/integration-accounts/{accountId}",
+        summary: "Disconnect integration account",
+        tags: ["Integration Accounts"],
+    })
+        .input(organizationAccountInputSchema)
         .output(z.object({ txid: z.number().int().nonnegative() })),
-    get: oc.input(z.object({ organizationId: z.string() })).output(z.object({
-        accounts: integrationAccountOutputSchema.array(),
+    get: oc
+        .route({
+        description: "Returns one integration account linked to an organization.",
+        method: "GET",
+        operationId: "getIntegrationAccount",
+        path: "/organizations/{organizationId}/integration-accounts/{accountId}",
+        summary: "Get integration account",
+        tags: ["Integration Accounts"],
+    })
+        .input(organizationAccountInputSchema)
+        .output(integrationAccountOutputSchema),
+    list: oc
+        .route({
+        description: "Lists integration accounts linked to an organization.",
+        method: "GET",
+        operationId: "listIntegrationAccounts",
+        path: "/organizations/{organizationId}/integration-accounts",
+        summary: "List integration accounts",
+        tags: ["Integration Accounts"],
+    })
+        .input(cursorPaginationInputSchema.extend({ organizationId: z.string() }))
+        .output(cursorPageOutputSchema(integrationAccountOutputSchema.extend({ createdAt: z.date() }))),
+    listServices: oc
+        .route({
+        description: "Lists enabled integration services and their connection methods.",
+        method: "GET",
+        operationId: "listIntegrationServices",
+        path: "/integration-services",
+        summary: "List integration services",
+        tags: ["Integration Accounts"],
+    })
+        .input(z.object({}).default({}))
+        .output(integrationServiceOutputSchema.array()),
+    revocationImpact: oc
+        .route({
+        description: "Previews platform-wide revocation while redacting inaccessible organizations.",
+        method: "GET",
+        operationId: "getIntegrationAccountRevocationImpact",
+        path: "/organizations/{organizationId}/integration-accounts/{accountId}/revocation-impact",
+        summary: "Preview integration account revocation",
+        tags: ["Integration Accounts"],
+    })
+        .input(organizationAccountInputSchema)
+        .output(integrationAccountRevocationImpactOutputSchema),
+    revoke: oc
+        .route({
+        description: "Immediately blocks and globally revokes a shared integration account.",
+        method: "POST",
+        operationId: "revokeIntegrationAccount",
+        path: "/organizations/{organizationId}/integration-accounts/{accountId}/revoke",
+        successStatus: 202,
+        summary: "Revoke integration account",
+        tags: ["Integration Accounts"],
+    })
+        .input(organizationAccountInputSchema)
+        .output(z.object({
+        revocation: integrationAccountRevocationOutputSchema,
+        txid: z.number().int().nonnegative(),
     })),
     submitCredentials: oc
+        .route({
+        description: "Validates secret form credentials and links the resulting account.",
+        method: "POST",
+        operationId: "connectIntegrationAccountCredentials",
+        path: "/organizations/{organizationId}/integration-account-credentials",
+        successStatus: 201,
+        summary: "Connect integration account credentials",
+        tags: ["Integration Accounts"],
+    })
         .input(z.object({
-        connectionId: z.string().min(1),
+        connectionMethodId: z.string().min(1),
         data: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])),
         organizationId: z.string(),
         serviceId: z.string().min(1),
     }))
-        .output(z.void()),
+        .output(z.object({ accountId: z.string() })),
 };

package/dist/api-key.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 export declare const organizationApiKeyOutputSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodNullable<z.ZodString>;
@@ -33,15 +33,23 @@ export declare const apiKeyContract: {
         keyId: z.ZodString;
     }, z.core.$strip>, z.ZodVoid, Record<never, never>, Record<never, never>>;
     list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
         organizationId: z.ZodString;
-    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodNullable<z.ZodString>;
-        start: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodDate;
-        updatedAt: z.ZodDate;
-        expiresAt: z.ZodNullable<z.ZodDate>;
-    }, z.core.$strip>>, Record<never, never>, Record<never, never>>;
+    }, z.core.$strip>, z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            start: z.ZodNullable<z.ZodString>;
+            createdAt: z.ZodDate;
+            updatedAt: z.ZodDate;
+            expiresAt: z.ZodNullable<z.ZodDate>;
+        }, z.core.$strip>>;
+        pageInfo: z.ZodObject<{
+            hasMore: z.ZodBoolean;
+            nextCursor: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, Record<never, never>, Record<never, never>>;
     update: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
         keyId: z.ZodString;
         name: z.ZodString;

package/dist/api-key.js

@@ -1,6 +1,6 @@
 import { oc } from "@orpc/contract";
-import { z } from "zod";
-import { reasonableNameSchema } from "./schemas.js";
+import * as z from "zod";
+import { cursorPageOutputSchema, cursorPaginationInputSchema, reasonableNameSchema, } from "./schemas.js";
 export const organizationApiKeyOutputSchema = z.object({
     id: z.string(),
     name: z.string().nullable(),
@@ -50,8 +50,8 @@ export const apiKeyContract = {
         description: "Lists API keys owned by an organization. Requires apiKey:read.",
         tags: ["API Keys"],
     })
-        .input(z.object({ organizationId: z.string() }))
-        .output(organizationApiKeyOutputSchema.array()),
+        .input(cursorPaginationInputSchema.extend({ organizationId: z.string() }))
+        .output(cursorPageOutputSchema(organizationApiKeyOutputSchema)),
     update: oc
         .route({
         method: "PATCH",

package/dist/auth.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 export declare const userOutputSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;

package/dist/auth.js

@@ -1,5 +1,5 @@
 import { oc } from "@orpc/contract";
-import { z } from "zod";
+import * as z from "zod";
 export const userOutputSchema = z.object({
     id: z.string(),
     name: z.string(),

package/dist/authorization.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 type ScopeRequirement = string | {
     requirements: ScopeRequirement[];
     type: "and" | "or";
@@ -6,7 +6,7 @@ type ScopeRequirement = string | {
 export declare const authorizationContract: {
     beginConnection: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
         binding: z.ZodString;
-        connectionId: z.ZodString;
+        connectionMethodId: z.ZodString;
         deploymentId: z.ZodString;
         serviceId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
@@ -24,7 +24,7 @@ export declare const authorizationContract: {
     }, z.core.$strip>, z.ZodObject<{
         accounts: z.ZodArray<z.ZodObject<{
             checkedAt: z.ZodNullable<z.ZodDate>;
-            connectionId: z.ZodString;
+            connectionMethodId: z.ZodString;
             error: z.ZodNullable<z.ZodObject<{
                 code: z.ZodString;
                 message: z.ZodString;
@@ -39,7 +39,7 @@ export declare const authorizationContract: {
             accountId: z.ZodNullable<z.ZodString>;
             binding: z.ZodString;
             connections: z.ZodArray<z.ZodObject<{
-                connectionId: z.ZodString;
+                connectionMethodId: z.ZodString;
                 minimalScopes: z.ZodArray<z.ZodString>;
                 requiredScopes: z.ZodArray<z.ZodType<ScopeRequirement, unknown, z.core.$ZodTypeInternals<ScopeRequirement, unknown>>>;
             }, z.core.$strip>>;
@@ -55,7 +55,7 @@ export declare const authorizationContract: {
     }, z.core.$strip>, Record<never, never>, Record<never, never>>;
     submitCredentials: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
         binding: z.ZodString;
-        connectionId: z.ZodString;
+        connectionMethodId: z.ZodString;
         data: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
         deploymentId: z.ZodString;
         serviceId: z.ZodString;

package/dist/authorization.js

@@ -1,5 +1,5 @@
 import { oc } from "@orpc/contract";
-import { z } from "zod";
+import * as z from "zod";
 const SCOPE_REQUIREMENT_SCHEMA = z.lazy(() => z.union([
     z.string(),
     z.strictObject({
@@ -11,7 +11,7 @@ export const authorizationContract = {
     beginConnection: oc
         .input(z.object({
         binding: z.string().min(1),
-        connectionId: z.string().min(1),
+        connectionMethodId: z.string().min(1),
         deploymentId: z.string(),
         serviceId: z.string().min(1),
     }))
@@ -33,6 +33,14 @@ export const authorizationContract = {
         headers: z.object({ location: z.url() }),
     })),
     get: oc
+        .route({
+        method: "GET",
+        path: "/deployments/{deploymentId}/authorization",
+        operationId: "getDeploymentAuthorization",
+        summary: "Get deployment authorization",
+        description: "Returns connected accounts and the authorization requirements for a deployment.",
+        tags: ["Deployments"],
+    })
         .input(z.object({
         deploymentId: z.string(),
     }))
@@ -40,7 +48,7 @@ export const authorizationContract = {
         accounts: z
             .object({
             checkedAt: z.date().nullable(),
-            connectionId: z.string().min(1),
+            connectionMethodId: z.string().min(1),
             error: z
                 .object({
                 code: z.string(),
@@ -60,7 +68,7 @@ export const authorizationContract = {
             binding: z.string(),
             connections: z
                 .object({
-                connectionId: z.string().min(1),
+                connectionMethodId: z.string().min(1),
                 minimalScopes: z.string().array(),
                 requiredScopes: SCOPE_REQUIREMENT_SCHEMA.array(),
             })
@@ -73,12 +81,20 @@ export const authorizationContract = {
             .array(),
     })),
     proceed: oc
+        .route({
+        method: "POST",
+        path: "/deployments/{deploymentId}/authorization/proceed",
+        operationId: "proceedWithDeploymentAuthorization",
+        summary: "Proceed with deployment authorization",
+        description: "Continues a deployment after every integration requirement is satisfied.",
+        tags: ["Deployments"],
+    })
         .input(z.object({ deploymentId: z.string() }))
         .output(z.object({ txid: z.number().int().nonnegative() })),
     submitCredentials: oc
         .input(z.object({
         binding: z.string().min(1),
-        connectionId: z.string().min(1),
+        connectionMethodId: z.string().min(1),
         data: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])),
         deploymentId: z.string(),
         serviceId: z.string().min(1),