@membranehq/sdk 0.15.6 → 0.16.0

package/dist/bundle.d.ts

@@ -504,6 +504,11 @@ declare const ConnectUIOptions: z.ZodObject<{
     connectionParameters: z.ZodOptional<z.ZodAny>;
     allowMultipleConnections: z.ZodOptional<z.ZodBoolean>;
     customState: z.ZodOptional<z.ZodString>;
+    theme: z.ZodOptional<z.ZodEnum<{
+        light: "light";
+        dark: "dark";
+        auto: "auto";
+    }>>;
 }, z.core.$strip>;
 type ConnectUIOptions = z.infer<typeof ConnectUIOptions>;
 type ConnectOptions = ConnectPayload & {

package/dist/bundle.js

@@ -7898,7 +7898,7 @@
 	const version = {
 	    major: 4,
 	    minor: 3,
-	    patch: 5,
+	    patch: 6,
 	};
 
 	const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
@@ -9260,11 +9260,9 @@
 	                if (keyResult instanceof Promise) {
 	                    throw new Error("Async schemas not supported in object keys currently");
 	                }
-	                // Numeric string fallback: if key failed with "expected number", retry with Number(key)
-	                const checkNumericKey = typeof key === "string" &&
-	                    number$2.test(key) &&
-	                    keyResult.issues.length &&
-	                    keyResult.issues.some((iss) => iss.code === "invalid_type" && iss.expected === "number");
+	                // Numeric string fallback: if key is a numeric string and failed, retry with Number(key)
+	                // This handles z.number(), z.literal([1, 2, 3]), and unions containing numeric literals
+	                const checkNumericKey = typeof key === "string" && number$2.test(key) && keyResult.issues.length;
 	                if (checkNumericKey) {
 	                    const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
 	                    if (retryResult instanceof Promise) {
@@ -16917,7 +16915,7 @@
 	                }
 	            }
 	            // When ref was extracted to $defs, remove properties that match the definition
-	            if (refSchema.$ref) {
+	            if (refSchema.$ref && refSeen.def) {
 	                for (const key in schema) {
 	                    if (key === "$ref" || key === "allOf")
 	                        continue;
@@ -22189,36 +22187,64 @@
 	    WorkspaceElementDependencyType["Parent"] = "PARENT";
 	})(WorkspaceElementDependencyType || (WorkspaceElementDependencyType = {}));
 	const BaseWorkspaceElement = object({
-	    id: string$1(),
-	    name: string$1(),
+	    id: string$1().describe('Internal database ID of the element. Assigned by the API; unique per element.'),
+	    name: string$1().describe('Display name of the workspace element.'),
 	});
 	const BaseMembraneInterfaceEditableProperties = object({
-	    uuid: string$1().optional(),
-	    key: string$1().optional(),
-	    name: string$1().optional(),
-	    description: string$1().optional(),
-	    meta: record(string$1(), any()).optional(),
+	    uuid: string$1()
+	        .optional()
+	        .describe('Stable unique identifier (UUID). Can be provided on create; otherwise generated. Must be unique across elements of this type.'),
+	    key: string$1()
+	        .optional()
+	        .describe('Stable key for referencing the element (e.g. in selectors). Unique per (parent, integration) scope. Generated from name if not provided on create.'),
+	    name: string$1().optional().describe('Display name. Optional on create; used to generate key when key is omitted.'),
+	    description: string$1().optional().describe('Optional human-readable description.'),
+	    meta: record(string$1(), any()).optional().describe('Optional key-value metadata.'),
 	});
 	const BaseMembraneInterfaceReadOnlyProperties = object({
-	    name: string$1(),
-	    state: _enum(WorkspaceElementState).optional(),
-	    errors: array(ErrorDataSchema).optional(),
-	    revision: string$1().optional(),
-	    createdAt: string$1().optional(),
-	    updatedAt: string$1().optional(),
-	    archivedAt: string$1().optional(),
-	    isDeactivated: boolean$1().optional(),
-	    isReadOnly: boolean$1().optional(),
+	    name: string$1().describe('Display name. Always present in API responses (filled by API if not set on create).'),
+	    state: _enum(WorkspaceElementState)
+	        .optional()
+	        .describe('Current lifecycle or health state (e.g. READY, SETUP_FAILED, CONFIGURATION_ERROR). Set by the engine during setup and validation.'),
+	    errors: array(ErrorDataSchema).optional().describe('Validation or setup errors when state is not READY.'),
+	    revision: string$1()
+	        .optional()
+	        .describe('Opaque revision token; changes on each update. Used for optimistic concurrency.'),
+	    createdAt: string$1().optional().describe('ISO date when the element was created.'),
+	    updatedAt: string$1().optional().describe('ISO date when the element was last updated.'),
+	    archivedAt: string$1()
+	        .optional()
+	        .describe('When set, the element is archived (soft-deleted). Archived elements cannot be patched.'),
+	    isDeactivated: boolean$1()
+	        .optional()
+	        .describe('When true, setup is skipped and the element is treated as inactive (e.g. when dependencies are deactivated or the element is archived).'),
+	    isReadOnly: boolean$1()
+	        .optional()
+	        .describe('When true, the element cannot be modified (e.g. published package elements or elements from another workspace).'),
 	});
 	const BaseMembraneInterface = BaseWorkspaceElement.merge(BaseMembraneInterfaceEditableProperties).merge(BaseMembraneInterfaceReadOnlyProperties);
 	const BaseIntegrationLevelMembraneInterfaceEditableProperties = BaseMembraneInterfaceEditableProperties.extend({
-	    integrationId: string$1().optional(),
-	    integrationUuid: string$1().optional(),
-	    parentId: string$1().optional(),
-	    parentUuid: string$1().optional(),
-	    connectionId: string$1().optional(),
-	    instanceKey: string$1().optional(),
-	    isUniversal: boolean$1().optional(),
+	    integrationId: string$1()
+	        .optional()
+	        .describe('Internal ID of the integration this element belongs to. Omit for universal elements; set for integration-specific elements. Uniqueness of key is scoped per integration.'),
+	    integrationUuid: string$1()
+	        .optional()
+	        .describe('UUID of the integration; alternative to integrationId when creating from export. Resolved to integrationId by the API.'),
+	    parentId: string$1()
+	        .optional()
+	        .describe('Internal ID of the parent workspace element. Used for hierarchy (e.g. integration-level under universal). Child key uniqueness is scoped by parent and integration.'),
+	    parentUuid: string$1()
+	        .optional()
+	        .describe('UUID of the parent element; alternative to parentId when creating (e.g. from export). Resolved to parentId by the API.'),
+	    connectionId: string$1()
+	        .optional()
+	        .describe('Connection ID. Used when filtering by connection in list/selector queries, or when creating or identifying connection-level instances.'),
+	    instanceKey: string$1()
+	        .optional()
+	        .describe('Key identifying a specific connection-level instance when multiple instances exist per (element, connection). Used in selector queries and when creating instances.'),
+	    isUniversal: boolean$1()
+	        .optional()
+	        .describe('When true, the element is universal (shared across all integrations). Requires universal-element access. Omit or false for integration-specific elements.'),
 	});
 	const BaseIntegrationLevelMembraneInterfaceReadOnlyProperties = BaseMembraneInterfaceReadOnlyProperties.extend({
 	    isCustomized: boolean$1().optional(),
@@ -24607,7 +24633,9 @@
 	    redirectUri: string$1().optional(),
 	    customState: string$1().optional(),
 	});
-	ConnectPayload.omit({ input: true, redirectUri: true });
+	ConnectPayload.omit({ input: true, redirectUri: true }).extend({
+	    theme: _enum(['light', 'dark', 'auto']).optional(),
+	});
 
 	class UI {
 	    constructor(client) {