@sdlcworks/components 0.0.35 → 0.0.36

package/dist/index.d.ts

@@ -136,6 +136,15 @@ export declare function extendSchema<TParentSchema extends z.ZodObject<z.ZodRawS
  * No metadata, only URI is provided.
  */
 export declare const PublicHTTPCI: ConnectionInterfaceDef<"public-http", z.ZodObject<{}, z.core.$strip>, undefined>;
+/**
+ * Connection type used by the orchestrator when performing anonymous URI discovery
+ * for URL register component collection. Infra component connect handlers that expose
+ * interfaces consumed by URL registers must accept this connection type.
+ *
+ * If your infra component's connect handler does not handle this type, the orchestrator
+ * will raise an error instructing you to add support for it.
+ */
+export declare const ANONYMOUS_CONNECTION_TYPE: "@anonymous";
 /**
  * Extract the inferred data type from a ConnectionInterfaceDef.
  */
@@ -235,15 +244,31 @@ export type ProviderPulumiCtx<I, S, P extends CloudProvider = CloudProvider> = {
 	getCredentials: GetCredentialsFn<P>;
 };
 /**
- * Context passed to connection handlers.
- * Contains the provider state, typed data from the connecting component,
- * the connection type chosen by the orchestrator, and getCredentials function.
+ * Context passed to the connect function.
+ * Called once per app component requesting a connection.
+ * The connect function returns handler entries that can capture this context via closure.
  */
-export type ConnectionHandlerCtx<S, ConnectorData, ConnectionType extends string = string, P extends CloudProvider = CloudProvider> = {
+export type ConnectFnCtx<S, P extends CloudProvider = CloudProvider> = {
 	state: S;
+	getCredentials: GetCredentialsFn<P>;
+	componentName: string;
+};
+/**
+ * Reduced context passed to individual connection handlers.
+ * Only contains the per-invocation essentials (connectionData, connectionType, and $).
+ * Handlers access state, getCredentials, and componentName via closure from the connect function.
+ *
+ * $ - Naming function for Pulumi resources created by this handler. Always use $ for resource
+ * names so the orchestrator can track which resources are created by connection logic and
+ * apply the correct delete-protection policy (connection resources are ephemeral and un-protected).
+ */
+export type ConnectHandlerCtx<ConnectorData, ConnectionType extends string = string> = {
 	connectionData: ConnectorData;
 	connectionType: ConnectionType;
-	getCredentials: GetCredentialsFn<P>;
+	$: {
+		(name: string, ...values: any[]): string;
+		(strings: TemplateStringsArray, ...values: any[]): string;
+	};
 };
 /**
  * Result returned by connection handlers.
@@ -261,11 +286,13 @@ export type ConnectionHandlerResult<TMetadata = undefined> = {
 };
 /**
  * A connection handler entry mapping a ConnectionInterfaceDef to its handler function.
+ * The handler receives a reduced context (connectionData and connectionType only).
+ * State, getCredentials, and componentName are accessed via closure from the connect function.
  * The handler returns typed metadata based on the interface's resultSchema.
  */
-export type ConnectionHandlerEntry<S, ConnectionType extends string, D extends ConnectionInterfaceDef, P extends CloudProvider = CloudProvider> = {
+export type ConnectionHandlerEntry<ConnectionType extends string, D extends ConnectionInterfaceDef> = {
 	interface: D;
-	handler: (ctx: ConnectionHandlerCtx<S, InferConnectionData<D>, ConnectionType, P>) => Promise<ConnectionHandlerResult<InferConnectionResultMetadata<D>>>;
+	handler: (ctx: ConnectHandlerCtx<InferConnectionData<D>, ConnectionType>) => Promise<ConnectionHandlerResult<InferConnectionResultMetadata<D>>>;
 };
 /**
  * Type definition for a connection handler entry.
@@ -273,9 +300,56 @@ export type ConnectionHandlerEntry<S, ConnectionType extends string, D extends C
  */
 export type ConnectionHandlerDef<D extends ConnectionInterfaceDef> = {
 	interface: D;
-	handler: (ctx: ConnectionHandlerCtx<any, InferConnectionData<D>, any>) => Promise<ConnectionHandlerResult<InferConnectionResultMetadata<D>>>;
+	handler: (ctx: ConnectHandlerCtx<InferConnectionData<D>, any>) => Promise<ConnectionHandlerResult<InferConnectionResultMetadata<D>>>;
 };
 export declare function connectionHandler<D extends ConnectionInterfaceDef>(entry: ConnectionHandlerDef<D>): ConnectionHandlerDef<D>;
+/**
+ * Type for the connect function.
+ * Called once per app component requesting a connection.
+ * Returns an array of handler entries that can use the context via closure.
+ */
+export type ConnectFn<S, ConnectionType extends string, P extends CloudProvider = CloudProvider> = (ctx: ConnectFnCtx<S, P>) => readonly ConnectionHandlerEntry<ConnectionType, any>[];
+/**
+ * Component entry in the URLRegister provision context.
+ * Reference metadata for components, keyed by their original URI.
+ *
+ * The provision function may or may not use this reference data.
+ * Metadata is fully typed based on the ConnectionInterface's resultSchema.
+ */
+export type URLRegisterComponentEntry<TInterface extends ConnectionInterfaceDef> = {
+	component: string;
+	metadata: InferConnectionResultMetadata<TInterface> extends undefined ? Record<string, never> : {
+		[K in keyof InferConnectionResultMetadata<TInterface>]: PulumiInput<InferConnectionResultMetadata<TInterface>[K]>;
+	};
+};
+/**
+ * Context passed to the URLRegister provision function.
+ *
+ * @property config - Global configuration + URL map definition (user-defined routes/URLs to provision)
+ * @property state - Mutable state for this URLRegister instance
+ * @property components - Reference metadata keyed by original URI (may or may not be used by provision function)
+ * @property $ - Naming helper for Pulumi resource names
+ *
+ * Fully typed based on configSchema, stateSchema, and the declared ConnectionInterface.
+ */
+export type URLRegisterProvisionCtx<TConfig, TInterface extends ConnectionInterfaceDef, S> = {
+	config: TConfig;
+	state: S;
+	components: Record<string, URLRegisterComponentEntry<TInterface>>;
+	$: {
+		(name: string, ...values: any[]): string;
+		(strings: TemplateStringsArray, ...values: any[]): string;
+	};
+};
+/**
+ * Result returned by the URLRegister provision function.
+ * Maps component names to their provisioned URIs.
+ */
+export type URLRegisterProvisionResult = Record<string, PulumiOutput<string>>;
+/**
+ * Type-erased storage for URLRegister provision function.
+ */
+export type StoredProvisionFn = (ctx: URLRegisterProvisionCtx<any, any, any>) => Promise<URLRegisterProvisionResult>;
 export type ProviderDeployCtx<D, S, P extends CloudProvider = CloudProvider> = {
 	state: S;
 	getCredentials: GetCredentialsFn<P>;
@@ -291,6 +365,19 @@ export type ProviderAllocateCtx<S, P extends CloudProvider = CloudProvider> = {
 	envStore: EnvStore;
 	getCredentials: GetCredentialsFn<P>;
 };
+export type ProviderAllocateWithPulumiCtxCtx<S, P extends CloudProvider = CloudProvider> = {
+	name: string;
+	deploymentConfig: Record<string, any>;
+	state: S;
+	$: {
+		(name: string, ...values: any[]): string;
+		(strings: TemplateStringsArray, ...values: any[]): string;
+	};
+	envStore: EnvStore;
+	getCredentials: GetCredentialsFn<P>;
+	/** Build artifact for this app component, if available. */
+	buildArtifact?: ArtifactInfo;
+};
 export type ProviderDeallocateCtx<S, P extends CloudProvider = CloudProvider> = {
 	name: string;
 	deploymentConfig: Record<string, any>;
@@ -310,6 +397,7 @@ export type ProviderUpsertArtifactsCtx<S, P extends CloudProvider = CloudProvide
 export type ProviderPulumiFn<I, S, O, P extends CloudProvider = CloudProvider> = (ctx: ProviderPulumiCtx<I, S, P>) => Promise<O>;
 export type ProviderDeployFn<D, S, P extends CloudProvider = CloudProvider> = (ctx: ProviderDeployCtx<D, S, P>) => Promise<void>;
 export type ProviderAllocateFn<S, P extends CloudProvider = CloudProvider> = (ctx: ProviderAllocateCtx<S, P>) => Promise<void>;
+export type ProviderAllocateWithPulumiCtxFn<S, P extends CloudProvider = CloudProvider> = (ctx: ProviderAllocateWithPulumiCtxCtx<S, P>) => Promise<void>;
 export type ProviderDeallocateFn<S, P extends CloudProvider = CloudProvider> = (ctx: ProviderDeallocateCtx<S, P>) => Promise<void>;
 export type ProviderUpsertArtifactsFn<S, P extends CloudProvider = CloudProvider> = (ctx: ProviderUpsertArtifactsCtx<S, P>) => Promise<void>;
 declare const emptyStateSchema: z.ZodObject<{}, z.core.$strip>;
@@ -330,29 +418,28 @@ export type ProviderFnsDef<I, D, O, SShape extends z.ZodRawShape = EmptyStateSha
 	stateSchema?: z.ZodObject<SShape>;
 	initialState?: Partial<S>;
 	pulumi: ProviderPulumiFn<I, S, O, P>;
-	connect?: readonly ConnectionHandlerEntry<S, ConnectionType, any>[];
+	connect?: ConnectFn<S, ConnectionType, P>;
 	deploy?: ProviderDeployFn<D, S, P>;
 	allocateComponent?: ProviderAllocateFn<S, P>;
 	deallocateComponent?: ProviderDeallocateFn<S, P>;
+	/**
+	 * Pulumi-context allocation: creates declarative Pulumi resources per app component.
+	 * Mutually exclusive with `allocateComponent` — defining both will throw an error.
+	 * Unlike `allocateComponent` (imperative side-effects), resources created here are
+	 * tracked by Pulumi and automatically destroyed when the app component is removed.
+	 */
+	allocateWithPulumiCtx?: ProviderAllocateWithPulumiCtxFn<S, P>;
 	upsertArtifacts?: ProviderUpsertArtifactsFn<S, P>;
 };
-/**
- * Stored version of ConnectionHandlerEntry that preserves ConnectionInterfaceDef type.
- * This ensures `interface` is always typed as ConnectionInterfaceDef (not any)
- * when accessing from the registry, allowing runtime schema access.
- */
-export type StoredConnectionHandlerEntry = {
-	interface: ConnectionInterfaceDef<string, any, any>;
-	handler: (ctx: ConnectionHandlerCtx<any, any, any, any>) => Promise<ConnectionHandlerResult<any>>;
-};
 export type StoredProviderFns = {
 	stateSchema: z.ZodObject<any>;
 	initialState?: any;
 	pulumi: ProviderPulumiFn<any, any, any, any>;
-	connect?: readonly StoredConnectionHandlerEntry[];
+	connect?: ConnectFn<any, any, any>;
 	deploy?: ProviderDeployFn<any, any, any>;
 	allocateComponent?: ProviderAllocateFn<any, any>;
 	deallocateComponent?: ProviderDeallocateFn<any, any>;
+	allocateWithPulumiCtx?: ProviderAllocateWithPulumiCtxFn<any, any>;
 	upsertArtifacts?: ProviderUpsertArtifactsFn<any, any>;
 };
 export type ProviderRegistry = Partial<Record<CloudProvider, StoredProviderFns>>;
@@ -395,5 +482,81 @@ export declare class InfraComponent<CShape extends z.ZodRawShape, DShape extends
 	 */
 	getDeclaredInterfaces(): DeclaredConnectionInterfaces;
 }
+/**
+ * URLRegister component for managing URL routing/registration (e.g., DNS, LB paths).
+ *
+ * Provider-agnostic: runs at app-layer, not tied to specific cloud providers.
+ *
+ * ## Conceptual Model
+ *
+ * - **`interface` field**: Required metadata for SDLC orchestrator (determines which components get passed)
+ * - **`configSchema`**: Defines global settings + URL map (routes/paths the user wants to provision)
+ * - **`ctx.components`**: Reference metadata keyed by URI (provision function may or may not use this)
+ * - **Return type**: Component name → rewritten URI (can be empty `{}` if no rewriting needed)
+ *
+ * @param TName - Unique name for this URLRegister
+ * @param TInterface - The ConnectionInterfaceDef this register handles (orchestrator metadata)
+ * @param CShape - Zod shape for the config schema (global settings + URL map definition)
+ * @param SShape - Zod shape for the state schema (default: empty)
+ *
+ * @example
+ * const BackendServiceCI = defineConnectionInterface(
+ *   "backend-service",
+ *   z.object({ backendServiceId: z.string() }),
+ *   z.object({ region: z.string(), port: z.number() })
+ * );
+ *
+ * const lbPathRegister = new URLRegister({
+ *   name: "lb-path-manager",
+ *   interface: BackendServiceCI,  // Orchestrator uses this to route components
+ *   configSchema: z.object({
+ *     domain: z.string(),
+ *     urlMapId: z.string(),
+ *     routes: z.array(z.object({
+ *       path: z.string(),
+ *       targetComponent: z.string(),
+ *     })),
+ *   }),
+ *   provision: async (ctx) => {
+ *     // ctx.config: { domain, urlMapId, routes: [...] }
+ *     // ctx.components: { [uri: string]: { component: string, metadata: {...typed...} } }
+ *
+ *     const results: Record<string, pulumi.Output<string>> = {};
+ *     for (const route of ctx.config.routes) {
+ *       // Find component's original URI if needed
+ *       const componentEntry = Object.entries(ctx.components)
+ *         .find(([_, entry]) => entry.component === route.targetComponent);
+ *
+ *       if (componentEntry) {
+ *         const [originalUri, entry] = componentEntry;
+ *         // Use originalUri and entry.metadata as needed
+ *         results[entry.component] = pulumi.interpolate`https://${ctx.config.domain}${route.path}`;
+ *       }
+ *     }
+ *     return results;  // Can be {} if no rewriting needed
+ *   },
+ * });
+ */
+export declare class URLRegister<TName extends string, TInterface extends ConnectionInterfaceDef, CShape extends z.ZodRawShape, SShape extends z.ZodRawShape = EmptyStateShape> {
+	readonly name: TName;
+	readonly interface: TInterface;
+	readonly configSchema: z.ZodObject<CShape>;
+	readonly stateSchema: z.ZodObject<SShape>;
+	readonly validationSchema: z.ZodTypeAny;
+	private readonly provisionFn;
+	readonly initialState?: Partial<RuntimeState<SShape>>;
+	constructor(opts: {
+		name: TName;
+		interface: TInterface;
+		configSchema: z.ZodObject<CShape>;
+		stateSchema?: z.ZodObject<SShape>;
+		initialState?: Partial<RuntimeState<SShape>>;
+		provision: (ctx: URLRegisterProvisionCtx<InferZodType<CShape>, TInterface, RuntimeState<SShape>>) => Promise<URLRegisterProvisionResult>;
+	});
+	/**
+	 * Get the provision function (for orchestrator use).
+	 */
+	getProvision(): StoredProvisionFn;
+}
 
 export {};

package/dist/index.js

@@ -1,158 +1 @@
-// src/infra.ts
-import { z } from "zod";
-import * as pulumi from "@pulumi/pulumi";
-
-// src/copied-types.ts
-var CloudProvider;
-((CloudProvider2) => {
-  CloudProvider2["aws"] = "aws";
-  CloudProvider2["gcloud"] = "gcloud";
-  CloudProvider2["azure"] = "azure";
-  CloudProvider2["linode"] = "linode";
-  CloudProvider2["hetzner"] = "hetzner";
-  CloudProvider2["cloudflare"] = "cloudflare";
-})(CloudProvider ||= {});
-var DeploymentArtifactType;
-((DeploymentArtifactType2) => {
-  DeploymentArtifactType2["oci_spec_image"] = "oci_spec_image";
-  DeploymentArtifactType2["file"] = "file";
-})(DeploymentArtifactType ||= {});
-
-// src/infra.ts
-var connectionInterfaceRegistry = new Map;
-function toCanonicalInterfaceName(name) {
-  return name.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase().replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-function registerInterfaceName(name) {
-  const canonical = toCanonicalInterfaceName(name);
-  if (canonical.length === 0) {
-    throw new Error(`Connection interface name cannot be empty`);
-  }
-  const existing = connectionInterfaceRegistry.get(canonical);
-  if (existing !== undefined && existing !== name) {
-    throw new Error(`Connection interface name collision: '${name}' resolves to '${canonical}' which is already registered by '${existing}'`);
-  }
-  connectionInterfaceRegistry.set(canonical, name);
-  return canonical;
-}
-function defineConnectionInterface(name, schema, resultSchema) {
-  const canonicalName = registerInterfaceName(name);
-  return {
-    name: canonicalName,
-    schema,
-    resultSchema
-  };
-}
-function extendSchema(parentDef, additionalSchema) {
-  return parentDef.schema.merge(additionalSchema);
-}
-var PublicHTTPCI = defineConnectionInterface("public-http", z.object({}));
-var emptyOutputSchema = z.object({});
-function transformSchemaToAcceptOutputs(schema) {
-  if (schema instanceof z.ZodObject) {
-    const shape = schema.shape;
-    const newShape = {};
-    for (const key in shape) {
-      newShape[key] = transformSchemaToAcceptOutputs(shape[key]);
-    }
-    return z.object(newShape);
-  }
-  if (schema instanceof z.ZodOptional) {
-    return transformSchemaToAcceptOutputs(schema.unwrap()).optional();
-  }
-  if (schema instanceof z.ZodNullable) {
-    return transformSchemaToAcceptOutputs(schema.unwrap()).nullable();
-  }
-  if (schema instanceof z.ZodDefault) {
-    return transformSchemaToAcceptOutputs(schema._def.innerType).default(schema._def.defaultValue);
-  }
-  if (schema instanceof z.ZodArray) {
-    return z.array(transformSchemaToAcceptOutputs(schema.element));
-  }
-  if (schema instanceof z.ZodDiscriminatedUnion) {
-    const transformedOptions = schema._def.options.map((option) => transformSchemaToAcceptOutputs(option));
-    return z.discriminatedUnion(schema._def.discriminator, transformedOptions);
-  }
-  if (schema instanceof z.ZodRecord) {
-    const keyType = schema._def.keyType;
-    const valueType = schema._def.valueType;
-    const transformedKey = keyType ? transformSchemaToAcceptOutputs(keyType) : z.string();
-    const transformedValue = valueType ? transformSchemaToAcceptOutputs(valueType) : z.any();
-    return z.record(transformedKey, transformedValue);
-  }
-  return z.union([
-    schema,
-    z.custom((val) => pulumi.Output.isInstance(val))
-  ]);
-}
-var InfraComponentOptsSchema = z.object({
-  metadata: z.object({
-    stateful: z.boolean(),
-    proxiable: z.boolean()
-  }),
-  connectionTypes: z.record(z.string(), z.object({
-    description: z.string().min(5)
-  })),
-  configSchema: z.custom(),
-  deploymentInputSchema: z.custom(),
-  outputSchema: z.custom()
-});
-function connectionHandler(entry) {
-  return entry;
-}
-var emptyStateSchema = z.object({});
-
-class InfraComponent {
-  opts;
-  providers;
-  validationSchema;
-  validationDeploymentInputSchema;
-  declaredConnectionInterfaces = new Map;
-  constructor(opts) {
-    this.opts = InfraComponentOptsSchema.parse(opts);
-    this.providers = {};
-    this.validationSchema = transformSchemaToAcceptOutputs(opts.configSchema);
-    this.validationDeploymentInputSchema = transformSchemaToAcceptOutputs(opts.deploymentInputSchema);
-  }
-  implement(provider, fns) {
-    this.providers[provider] = {
-      ...fns,
-      stateSchema: fns.stateSchema ?? emptyStateSchema,
-      initialState: fns.initialState
-    };
-    return this;
-  }
-  getConnectionSchema(interfaceDef) {
-    return interfaceDef.schema;
-  }
-  createDeclareConnectionInterfacesFn() {
-    return (entries) => {
-      this.declaredConnectionInterfaces = new Map;
-      for (const entry of entries) {
-        const schema = entry.interface.schema;
-        const transformedSchema = transformSchemaToAcceptOutputs(schema);
-        const parseResult = transformedSchema.safeParse(entry.data);
-        if (!parseResult.success) {
-          throw new Error(`Invalid data for connection interface '${entry.interface.name}': ${parseResult.error.message}`);
-        }
-        this.declaredConnectionInterfaces.set(entry.interface.name, {
-          schema: transformedSchema,
-          data: entry.data
-        });
-      }
-    };
-  }
-  getDeclaredInterfaces() {
-    return this.declaredConnectionInterfaces;
-  }
-}
-export {
-  toCanonicalInterfaceName,
-  extendSchema,
-  defineConnectionInterface,
-  connectionHandler,
-  PublicHTTPCI,
-  InfraComponent,
-  DeploymentArtifactType,
-  CloudProvider
-};
+import{z as j}from"zod";import*as Z from"@pulumi/pulumi";var W;((M)=>{M.aws="aws";M.gcloud="gcloud";M.azure="azure";M.linode="linode";M.hetzner="hetzner";M.cloudflare="cloudflare"})(W||={});var X;((F)=>{F.oci_spec_image="oci_spec_image";F.file="file"})(X||={});var Y=new Map;function $(b){return b.replace(/([a-z])([A-Z])/g,"$1-$2").replace(/[_\s]+/g,"-").toLowerCase().replace(/-+/g,"-").replace(/^-|-$/g,"")}function q(b){let B=$(b);if(B.length===0)throw new Error("Connection interface name cannot be empty");let F=Y.get(B);if(F!==void 0&&F!==b)throw new Error(`Connection interface name collision: '${b}' resolves to '${B}' which is already registered by '${F}'`);return Y.set(B,b),B}function E(b,B,F){return{name:q(b),schema:B,resultSchema:F}}function k(b,B){return b.schema.merge(B)}var x=E("public-http",j.object({})),I="@anonymous",R=j.object({});function H(b){if(b instanceof j.ZodObject){let B=b.shape,F={};for(let J in B)F[J]=H(B[J]);return j.object(F)}if(b instanceof j.ZodOptional)return H(b.unwrap()).optional();if(b instanceof j.ZodNullable)return H(b.unwrap()).nullable();if(b instanceof j.ZodDefault)return H(b._def.innerType).default(b._def.defaultValue);if(b instanceof j.ZodArray)return j.array(H(b.element));if(b instanceof j.ZodDiscriminatedUnion){let B=b._def.options.map((F)=>H(F));return j.discriminatedUnion(b._def.discriminator,B)}if(b instanceof j.ZodRecord){let B=b._def.keyType,F=b._def.valueType,J=B?H(B):j.string(),Q=F?H(F):j.any();return j.record(J,Q)}return j.union([b,j.custom((B)=>Z.Output.isInstance(B))])}var G=j.object({metadata:j.object({stateful:j.boolean(),proxiable:j.boolean()}),connectionTypes:j.record(j.string(),j.object({description:j.string().min(5)})),configSchema:j.custom(),deploymentInputSchema:j.custom(),outputSchema:j.custom()});function g(b){return b}var _=j.object({});class K{opts;providers;validationSchema;validationDeploymentInputSchema;declaredConnectionInterfaces=new Map;constructor(b){this.opts=G.parse(b),this.providers={},this.validationSchema=H(b.configSchema),this.validationDeploymentInputSchema=H(b.deploymentInputSchema)}implement(b,B){if(B.allocateComponent&&B.allocateWithPulumiCtx)throw new Error(`Provider '${b}' cannot define both 'allocateComponent' and 'allocateWithPulumiCtx'. These are mutually exclusive allocation strategies.`);return this.providers[b]={...B,stateSchema:B.stateSchema??_,initialState:B.initialState},this}getConnectionSchema(b){return b.schema}createDeclareConnectionInterfacesFn(){return(b)=>{this.declaredConnectionInterfaces=new Map;for(let B of b){let F=B.interface.schema,J=H(F),Q=J.safeParse(B.data);if(!Q.success)throw new Error(`Invalid data for connection interface '${B.interface.name}': ${Q.error.message}`);this.declaredConnectionInterfaces.set(B.interface.name,{schema:J,data:B.data})}}}getDeclaredInterfaces(){return this.declaredConnectionInterfaces}}var L=j.object({name:j.string().min(1),interface:j.custom(),configSchema:j.custom(),stateSchema:j.custom().optional(),provision:j.function()});class U{name;interface;configSchema;stateSchema;validationSchema;provisionFn;initialState;constructor(b){L.parse(b),this.name=b.name,this.interface=b.interface,this.configSchema=b.configSchema,this.stateSchema=b.stateSchema??_,this.validationSchema=H(b.configSchema),this.provisionFn=b.provision,this.initialState=b.initialState}getProvision(){return this.provisionFn}}export{$ as toCanonicalInterfaceName,k as extendSchema,E as defineConnectionInterface,g as connectionHandler,U as URLRegister,x as PublicHTTPCI,K as InfraComponent,X as DeploymentArtifactType,W as CloudProvider,I as ANONYMOUS_CONNECTION_TYPE};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdlcworks/components",
-  "version": "0.0.35",
+  "version": "0.0.36",
   "module": "dist/index.js",
   "files": [
     "dist"