@noodleseed/one 0.162.0 → 0.163.0

package/node_modules/@noodle-borg/wire-contracts/dist/application-activity.d.ts

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+export declare const ApplicationActivitySchema: z.ZodObject<{
+    id: z.ZodString;
+    actorReference: z.ZodString;
+    tool: z.ZodString;
+    operation: z.ZodString;
+    connectionId: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodEnum<{
+        unknown: "unknown";
+        dispatching: "dispatching";
+        completed: "completed";
+        rejected: "rejected";
+        accepted: "accepted";
+        returned: "returned";
+    }>;
+    startedAt: z.ZodISODateTime;
+    completedAt: z.ZodOptional<z.ZodISODateTime>;
+    reference: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ApplicationActivityListResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        activities: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            actorReference: z.ZodString;
+            tool: z.ZodString;
+            operation: z.ZodString;
+            connectionId: z.ZodOptional<z.ZodString>;
+            outcome: z.ZodEnum<{
+                unknown: "unknown";
+                dispatching: "dispatching";
+                completed: "completed";
+                rejected: "rejected";
+                accepted: "accepted";
+                returned: "returned";
+            }>;
+            startedAt: z.ZodISODateTime;
+            completedAt: z.ZodOptional<z.ZodISODateTime>;
+            reference: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        historyDays: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationActivitySettingsSchema: z.ZodObject<{
+    revision: z.ZodString;
+    retentionDays: z.ZodNumber;
+    maximumDays: z.ZodNumber;
+    canEdit: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const ApplicationActivitySettingsResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        revision: z.ZodString;
+        retentionDays: z.ZodNumber;
+        maximumDays: z.ZodNumber;
+        canEdit: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationActivitySettingsSaveRequestSchema: z.ZodObject<{
+    expectedRevision: z.ZodString;
+    retentionDays: z.ZodNumber;
+}, z.core.$strict>;
+/** Clients tolerate additive response fields; writes and server output remain strict. */
+export declare const ApplicationActivityListClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        activities: z.ZodArray<z.ZodObject<{
+            actorReference: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            tool: z.ZodString;
+            operation: z.ZodString;
+            connectionId: z.ZodOptional<z.ZodString>;
+            outcome: z.ZodEnum<{
+                unknown: "unknown";
+                dispatching: "dispatching";
+                completed: "completed";
+                rejected: "rejected";
+                accepted: "accepted";
+                returned: "returned";
+            }>;
+            startedAt: z.ZodISODateTime;
+            completedAt: z.ZodOptional<z.ZodISODateTime>;
+            reference: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        historyDays: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ApplicationActivitySettingsClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        revision: z.ZodString;
+        retentionDays: z.ZodNumber;
+        maximumDays: z.ZodNumber;
+        canEdit: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ApplicationActivityPreviewResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"available">;
+        kind: z.ZodLiteral<"hypothetical">;
+        asOf: z.ZodISODateTime;
+        revision: z.ZodString;
+        currentMaximumDays: z.ZodNumber;
+        paidPeriodEnd: z.ZodISODateTime;
+        currentlyAccessibleCount: z.ZodNumber;
+        physicallyExpiresByPeriodEndCount: z.ZodNumber;
+        scenarios: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            maximumDays: z.ZodNumber;
+            additionallyHiddenAtPeriodEndCount: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"unavailable">;
+        reason: z.ZodLiteral<"no_verified_paid_period">;
+    }, z.core.$strict>], "state">;
+}, z.core.$strict>;
+export declare const ApplicationActivityPreviewClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        scenarios: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            maximumDays: z.ZodNumber;
+            additionallyHiddenAtPeriodEndCount: z.ZodNumber;
+        }, z.core.$strip>>;
+        state: z.ZodLiteral<"available">;
+        kind: z.ZodLiteral<"hypothetical">;
+        asOf: z.ZodISODateTime;
+        revision: z.ZodString;
+        currentMaximumDays: z.ZodNumber;
+        paidPeriodEnd: z.ZodISODateTime;
+        currentlyAccessibleCount: z.ZodNumber;
+        physicallyExpiresByPeriodEndCount: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        state: z.ZodLiteral<"unavailable">;
+        reason: z.ZodLiteral<"no_verified_paid_period">;
+    }, z.core.$strip>], "state">;
+}, z.core.$strip>;
+//# sourceMappingURL=application-activity.d.ts.map

package/node_modules/@noodle-borg/wire-contracts/dist/application-activity.js

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+export const ApplicationActivitySchema = z.strictObject({
+    id: z.string().regex(/^[a-f0-9]{64}$/),
+    actorReference: z.string().regex(/^[a-f0-9]{64}$/),
+    tool: z.string().min(1).max(128),
+    operation: z.string().min(1).max(128),
+    connectionId: z.string().max(128).optional(),
+    outcome: z.enum(['dispatching', 'completed', 'rejected', 'accepted', 'unknown', 'returned']),
+    startedAt: z.iso.datetime(),
+    completedAt: z.iso.datetime().optional(),
+    reference: z.string().max(256).optional(),
+});
+export const ApplicationActivityListResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        activities: z.array(ApplicationActivitySchema).max(100),
+        nextCursor: z.string().max(2048).optional(),
+        historyDays: z.number().int().min(1).max(365),
+    }),
+});
+export const ApplicationActivitySettingsSchema = z.strictObject({
+    revision: z.string().regex(/^[a-f0-9]{64}$/),
+    retentionDays: z.number().int().min(1).max(365),
+    maximumDays: z.number().int().min(1).max(365),
+    canEdit: z.boolean(),
+});
+export const ApplicationActivitySettingsResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: ApplicationActivitySettingsSchema,
+});
+export const ApplicationActivitySettingsSaveRequestSchema = z.strictObject({
+    expectedRevision: z.string().regex(/^[a-f0-9]{64}$/),
+    retentionDays: z.number().int().min(1).max(365),
+});
+/** Clients tolerate additive response fields; writes and server output remain strict. */
+export const ApplicationActivityListClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: z.object({
+        ...ApplicationActivityListResponseSchema.shape.data.shape,
+        activities: z
+            .array(z.object({
+            ...ApplicationActivitySchema.shape,
+            actorReference: ApplicationActivitySchema.shape.actorReference.optional(),
+        }))
+            .max(100),
+    }),
+});
+export const ApplicationActivitySettingsClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: z.object(ApplicationActivitySettingsSchema.shape),
+});
+const ActivityPreviewScenarioSchema = z.strictObject({
+    id: z.string().min(1).max(128),
+    label: z.string().min(1).max(128),
+    maximumDays: z.number().int().min(1).max(365),
+    additionallyHiddenAtPeriodEndCount: z.number().int().nonnegative(),
+});
+const ActivityPreviewAvailableSchema = z.strictObject({
+    state: z.literal('available'),
+    kind: z.literal('hypothetical'),
+    asOf: z.iso.datetime(),
+    revision: z.string().regex(/^[a-f0-9]{64}$/),
+    currentMaximumDays: z.number().int().min(1).max(365),
+    paidPeriodEnd: z.iso.datetime(),
+    currentlyAccessibleCount: z.number().int().nonnegative(),
+    physicallyExpiresByPeriodEndCount: z.number().int().nonnegative(),
+    scenarios: z.array(ActivityPreviewScenarioSchema).min(1).max(2),
+});
+const ActivityPreviewUnavailableSchema = z.strictObject({
+    state: z.literal('unavailable'),
+    reason: z.literal('no_verified_paid_period'),
+});
+export const ApplicationActivityPreviewResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.discriminatedUnion('state', [
+        ActivityPreviewAvailableSchema,
+        ActivityPreviewUnavailableSchema,
+    ]),
+});
+export const ApplicationActivityPreviewClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: z.discriminatedUnion('state', [
+        z.object({
+            ...ActivityPreviewAvailableSchema.shape,
+            scenarios: z.array(z.object(ActivityPreviewScenarioSchema.shape)).min(1).max(2),
+        }),
+        z.object(ActivityPreviewUnavailableSchema.shape),
+    ]),
+});
+//# sourceMappingURL=application-activity.js.map

package/node_modules/@noodle-borg/wire-contracts/dist/application-channels.d.ts

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+export declare const ApplicationChannelsProjectionSchema: z.ZodObject<{
+    revision: z.ZodNumber;
+    active: z.ZodBoolean;
+    canEdit: z.ZodBoolean;
+    deploymentId: z.ZodOptional<z.ZodString>;
+    mcp: z.ZodObject<{
+        status: z.ZodEnum<{
+            unavailable: "unavailable";
+            ready: "ready";
+            paused: "paused";
+        }>;
+        url: z.ZodOptional<z.ZodURL>;
+        accessMode: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    assistant: z.ZodObject<{
+        status: z.ZodEnum<{
+            unavailable: "unavailable";
+            ready: "ready";
+            paused: "paused";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+        embedId: z.ZodOptional<z.ZodString>;
+        scriptUrl: z.ZodOptional<z.ZodURL>;
+        serviceUrl: z.ZodOptional<z.ZodURL>;
+        origins: z.ZodArray<z.ZodURL>;
+        capabilities: z.ZodArray<z.ZodString>;
+        usage: z.ZodOptional<z.ZodObject<{
+            turnsPerDay: z.ZodNumber;
+            turnsToday: z.ZodNumber;
+            mintsPerDay: z.ZodNumber;
+            mintsToday: z.ZodNumber;
+            managedSpend: z.ZodOptional<z.ZodObject<{
+                state: z.ZodString;
+                turnsRemaining: z.ZodNumber;
+                visitors: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ApplicationChannelsProjection = z.infer<typeof ApplicationChannelsProjectionSchema>;
+export declare const ApplicationChannelsResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        revision: z.ZodNumber;
+        active: z.ZodBoolean;
+        canEdit: z.ZodBoolean;
+        deploymentId: z.ZodOptional<z.ZodString>;
+        mcp: z.ZodObject<{
+            status: z.ZodEnum<{
+                unavailable: "unavailable";
+                ready: "ready";
+                paused: "paused";
+            }>;
+            url: z.ZodOptional<z.ZodURL>;
+            accessMode: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        assistant: z.ZodObject<{
+            status: z.ZodEnum<{
+                unavailable: "unavailable";
+                ready: "ready";
+                paused: "paused";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+            embedId: z.ZodOptional<z.ZodString>;
+            scriptUrl: z.ZodOptional<z.ZodURL>;
+            serviceUrl: z.ZodOptional<z.ZodURL>;
+            origins: z.ZodArray<z.ZodURL>;
+            capabilities: z.ZodArray<z.ZodString>;
+            usage: z.ZodOptional<z.ZodObject<{
+                turnsPerDay: z.ZodNumber;
+                turnsToday: z.ZodNumber;
+                mintsPerDay: z.ZodNumber;
+                mintsToday: z.ZodNumber;
+                managedSpend: z.ZodOptional<z.ZodObject<{
+                    state: z.ZodString;
+                    turnsRemaining: z.ZodNumber;
+                    visitors: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationChannelsClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        revision: z.ZodNumber;
+        active: z.ZodBoolean;
+        canEdit: z.ZodBoolean;
+        deploymentId: z.ZodOptional<z.ZodString>;
+        mcp: z.ZodObject<{
+            status: z.ZodEnum<{
+                unavailable: "unavailable";
+                ready: "ready";
+                paused: "paused";
+            }>;
+            url: z.ZodOptional<z.ZodURL>;
+            accessMode: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        assistant: z.ZodObject<{
+            status: z.ZodEnum<{
+                unavailable: "unavailable";
+                ready: "ready";
+                paused: "paused";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+            embedId: z.ZodOptional<z.ZodString>;
+            scriptUrl: z.ZodOptional<z.ZodURL>;
+            serviceUrl: z.ZodOptional<z.ZodURL>;
+            origins: z.ZodArray<z.ZodURL>;
+            capabilities: z.ZodArray<z.ZodString>;
+            usage: z.ZodOptional<z.ZodObject<{
+                turnsPerDay: z.ZodNumber;
+                turnsToday: z.ZodNumber;
+                mintsPerDay: z.ZodNumber;
+                mintsToday: z.ZodNumber;
+                managedSpend: z.ZodOptional<z.ZodObject<{
+                    state: z.ZodString;
+                    turnsRemaining: z.ZodNumber;
+                    visitors: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ApplicationChannelsSaveRequestSchema: z.ZodObject<{
+    expectedRevision: z.ZodNumber;
+    active: z.ZodBoolean;
+}, z.core.$strict>;
+//# sourceMappingURL=application-channels.d.ts.map

package/node_modules/@noodle-borg/wire-contracts/dist/application-channels.js

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+const httpUrl = z.url().refine((value) => ['https:', 'http:'].includes(new URL(value).protocol));
+const status = z.enum(['ready', 'paused', 'unavailable']);
+const usage = z
+    .object({
+    turnsPerDay: z.number().int().nonnegative(),
+    turnsToday: z.number().int().nonnegative(),
+    mintsPerDay: z.number().int().nonnegative(),
+    mintsToday: z.number().int().nonnegative(),
+    managedSpend: z
+        .object({
+        state: z.string().min(1).max(64),
+        turnsRemaining: z.number().int().nonnegative(),
+        visitors: z.string().min(1).max(500),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+const mcp = z
+    .object({
+    status,
+    url: httpUrl.optional(),
+    accessMode: z.string().min(1).max(64).optional(),
+})
+    .strict();
+const assistant = z
+    .object({
+    status,
+    reason: z.string().min(1).max(200).optional(),
+    embedId: z
+        .string()
+        .regex(/^pub_[a-z0-9]{20,32}$/)
+        .optional(),
+    scriptUrl: httpUrl.optional(),
+    serviceUrl: httpUrl.optional(),
+    origins: z.array(httpUrl).max(128),
+    capabilities: z.array(z.string().min(1).max(128)).max(256),
+    usage: usage.optional(),
+})
+    .strict();
+export const ApplicationChannelsProjectionSchema = z
+    .object({
+    revision: z.number().int().positive(),
+    active: z.boolean(),
+    canEdit: z.boolean(),
+    deploymentId: z.string().min(1).max(256).optional(),
+    mcp,
+    assistant,
+})
+    .strict();
+export const ApplicationChannelsResponseSchema = z
+    .object({ ok: z.literal(true), data: ApplicationChannelsProjectionSchema })
+    .strict();
+export const ApplicationChannelsClientResponseSchema = z
+    .object({
+    ok: z.literal(true),
+    data: ApplicationChannelsProjectionSchema.extend({
+        mcp: mcp.strip(),
+        assistant: assistant
+            .extend({
+            usage: usage
+                .extend({ managedSpend: usage.shape.managedSpend.unwrap().strip().optional() })
+                .strip()
+                .optional(),
+        })
+            .strip(),
+    }).strip(),
+})
+    .strip();
+export const ApplicationChannelsSaveRequestSchema = z
+    .object({
+    expectedRevision: z.number().int().positive(),
+    active: z.boolean(),
+})
+    .strict();
+//# sourceMappingURL=application-channels.js.map

package/node_modules/@noodle-borg/wire-contracts/dist/application-connections.d.ts

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+export declare const ApplicationConnectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    state: z.ZodEnum<{
+        ready: "ready";
+        unconfigured: "unconfigured";
+        reauth_required: "reauth_required";
+        revoked: "revoked";
+    }>;
+    revision: z.ZodNumber;
+    connectable: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const ApplicationConnectionsProjectionSchema: z.ZodObject<{
+    connections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        state: z.ZodEnum<{
+            ready: "ready";
+            unconfigured: "unconfigured";
+            reauth_required: "reauth_required";
+            revoked: "revoked";
+        }>;
+        revision: z.ZodNumber;
+        connectable: z.ZodBoolean;
+    }, z.core.$strict>>;
+    canEdit: z.ZodBoolean;
+}, z.core.$strict>;
+export type ApplicationConnectionsProjection = z.infer<typeof ApplicationConnectionsProjectionSchema>;
+export declare const ApplicationConnectionsResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        connections: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            state: z.ZodEnum<{
+                ready: "ready";
+                unconfigured: "unconfigured";
+                reauth_required: "reauth_required";
+                revoked: "revoked";
+            }>;
+            revision: z.ZodNumber;
+            connectable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        canEdit: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationConnectionsClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        connections: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            state: z.ZodEnum<{
+                ready: "ready";
+                unconfigured: "unconfigured";
+                reauth_required: "reauth_required";
+                revoked: "revoked";
+            }>;
+            revision: z.ZodNumber;
+            connectable: z.ZodBoolean;
+        }, z.core.$strip>>;
+        canEdit: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ApplicationConnectionConnectRequestSchema: z.ZodObject<{
+    expectedRevision: z.ZodNumber;
+    returnUrl: z.ZodURL;
+    sessionBinding: z.ZodString;
+}, z.core.$strict>;
+export declare const ApplicationConnectionDisconnectRequestSchema: z.ZodObject<{
+    expectedRevision: z.ZodNumber;
+}, z.core.$strict>;
+export declare const ApplicationConnectionConnectResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        authorizationUrl: z.ZodURL;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationConnectionConnectClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        authorizationUrl: z.ZodURL;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ApplicationConnectionCallbackRequestSchema: z.ZodObject<{
+    state: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    iss: z.ZodOptional<z.ZodString>;
+    sessionBinding: z.ZodString;
+}, z.core.$strict>;
+export declare const ApplicationConnectionCallbackResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        returnUrl: z.ZodURL;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApplicationConnectionCallbackClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        returnUrl: z.ZodURL;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=application-connections.d.ts.map

package/node_modules/@noodle-borg/wire-contracts/dist/application-connections.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+const connectionUrl = z.url().refine((value) => {
+    const url = new URL(value);
+    return (!url.username &&
+        !url.password &&
+        !url.hash &&
+        (url.protocol === 'https:' ||
+            (url.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname))));
+}, 'HTTPS or explicit loopback HTTP URL required');
+const connectionShape = {
+    id: z.string().min(1).max(128),
+    label: z.string().min(1).max(200),
+    state: z.enum(['unconfigured', 'ready', 'reauth_required', 'revoked']),
+    revision: z.number().int().nonnegative(),
+    connectable: z.boolean(),
+};
+export const ApplicationConnectionSchema = z.strictObject(connectionShape);
+export const ApplicationConnectionsProjectionSchema = z.strictObject({
+    connections: z.array(ApplicationConnectionSchema).max(100),
+    canEdit: z.boolean(),
+});
+export const ApplicationConnectionsResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: ApplicationConnectionsProjectionSchema,
+});
+export const ApplicationConnectionsClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: z.object({
+        connections: z.array(z.object(connectionShape)).max(100),
+        canEdit: z.boolean(),
+    }),
+});
+const sessionBinding = z.string().regex(/^[A-Za-z0-9_-]{32,128}$/);
+export const ApplicationConnectionConnectRequestSchema = z.strictObject({
+    expectedRevision: z.number().int().nonnegative(),
+    returnUrl: connectionUrl.max(2048),
+    sessionBinding,
+});
+export const ApplicationConnectionDisconnectRequestSchema = z.strictObject({
+    expectedRevision: z.number().int().nonnegative(),
+});
+export const ApplicationConnectionConnectResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({ authorizationUrl: connectionUrl.max(8192) }),
+});
+export const ApplicationConnectionConnectClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: z.object({ authorizationUrl: connectionUrl.max(8192) }),
+});
+export const ApplicationConnectionCallbackRequestSchema = z
+    .strictObject({
+    state: z.string().regex(/^[A-Za-z0-9_-]{32,128}$/),
+    code: z.string().min(1).max(4096).optional(),
+    error: z.string().min(1).max(128).optional(),
+    iss: z.string().min(1).max(2048).optional(),
+    sessionBinding,
+})
+    .refine((value) => (value.code === undefined) !== (value.error === undefined), 'callback requires exactly one code or error');
+export const ApplicationConnectionCallbackResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({ returnUrl: connectionUrl.max(2048) }),
+});
+export const ApplicationConnectionCallbackClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: z.object({ returnUrl: connectionUrl.max(2048) }),
+});
+//# sourceMappingURL=application-connections.js.map

package/node_modules/@noodle-borg/wire-contracts/dist/application-onboarding.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const SolutionInstallationOptionsQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const SolutionInstallationOptionsResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        organizations: z.ZodArray<z.ZodObject<{
+            slug: z.ZodString;
+            displayName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const SolutionInstallationOptionsClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        organizations: z.ZodArray<z.ZodObject<{
+            slug: z.ZodString;
+            displayName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SolutionInstallationOptionsResponse = z.infer<typeof SolutionInstallationOptionsResponseSchema>;
+//# sourceMappingURL=application-onboarding.d.ts.map

package/node_modules/@noodle-borg/wire-contracts/dist/application-onboarding.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export const SolutionInstallationOptionsQuerySchema = z.strictObject({
+    limit: z.coerce.number().int().min(1).max(100).default(100),
+    cursor: z
+        .string()
+        .min(1)
+        .max(192)
+        .regex(/^[A-Za-z0-9_-]+$/)
+        .optional(),
+});
+function responseSchema(additive) {
+    const object = additive ? z.object : z.strictObject;
+    return object({
+        ok: z.literal(true),
+        data: object({
+            organizations: z
+                .array(object({
+                slug: z.string().min(1).max(100),
+                displayName: z.string().min(1).max(200).optional(),
+            }))
+                .max(100),
+            nextCursor: z.string().min(1).max(192).optional(),
+        }),
+    });
+}
+export const SolutionInstallationOptionsResponseSchema = responseSchema(false);
+export const SolutionInstallationOptionsClientResponseSchema = responseSchema(true);
+//# sourceMappingURL=application-onboarding.js.map