@crossplane-org/function-sdk-typescript 0.1.0

package/dist/resource/resource.d.ts

@@ -0,0 +1,101 @@
+import { Resource, Ready } from "../proto/run_function.js";
+export type ConnectionDetails = {
+    [key: string]: Buffer;
+};
+/**
+ * Composite represents a Crossplane composite resource (XR) with its state
+ */
+export interface Composite {
+    resource: Resource;
+    connectionDetails: ConnectionDetails;
+    ready: Ready;
+}
+/**
+ * ObservedComposed represents the observed state of a composed resource
+ */
+export interface ObservedComposed {
+    resource: Resource;
+    connectionDetails: ConnectionDetails;
+}
+/**
+ * DesiredComposed represents the desired state of a composed resource
+ */
+export interface DesiredComposed {
+    resource: Resource;
+    ready: Ready;
+}
+/**
+ * Create a new empty DesiredComposed resource
+ */
+export declare function newDesiredComposed(): DesiredComposed;
+/**
+ * Convert a protobuf Struct to a Kubernetes object (plain JavaScript object)
+ * This is a more efficient conversion that avoids JSON round-trips when possible
+ *
+ * @param struct - The protobuf Struct to convert
+ * @returns A plain JavaScript object representing the Kubernetes resource
+ */
+export declare function asObject(struct: {
+    [key: string]: any;
+} | undefined): {
+    [key: string]: any;
+};
+/**
+ * Convert a Kubernetes object to a protobuf Struct
+ * This is used when creating Resource objects from plain JavaScript objects
+ *
+ * @param obj - The plain JavaScript object to convert
+ * @returns A protobuf Struct representation
+ */
+export declare function asStruct(obj: {
+    [key: string]: any;
+}): {
+    [key: string]: any;
+};
+/**
+ * Helper function for tests: Convert an object to a Struct, panics on failure
+ * Only use this in test code
+ *
+ * @param obj - The object to convert
+ * @returns A Struct representation
+ * @throws Error if conversion fails
+ */
+export declare function mustStructObject(obj: {
+    [key: string]: any;
+}): {
+    [key: string]: any;
+};
+/**
+ * Helper function for tests: Parse a JSON string into a Struct, panics on failure
+ * Only use this in test code
+ *
+ * @param json - The JSON string to parse
+ * @returns A Struct representation
+ * @throws Error if parsing or conversion fails
+ */
+export declare function mustStructJSON(json: string): {
+    [key: string]: any;
+};
+/**
+ * Create a Resource from a plain JavaScript object
+ * This is a convenience wrapper around Resource.fromJSON
+ *
+ * @param obj - The resource object
+ * @param connectionDetails - Optional connection details
+ * @param ready - Optional ready status
+ * @returns A Resource
+ */
+export declare function fromObject(obj: {
+    [key: string]: any;
+}, connectionDetails?: ConnectionDetails, ready?: Ready): Resource;
+/**
+ * Get the resource object from a Resource
+ * This extracts the plain JavaScript object from the Resource wrapper
+ *
+ * @param resource - The Resource to extract from
+ * @returns The plain JavaScript object, or undefined if not present
+ */
+export declare function toObject(resource: Resource): {
+    [key: string]: any;
+} | undefined;
+//# sourceMappingURL=resource.d.ts.map

package/dist/resource/resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../src/resource/resource.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAG3D,MAAM,MAAM,iBAAiB,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,SAAS;IACtB,QAAQ,EAAE,QAAQ,CAAC;IACnB,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,KAAK,EAAE,KAAK,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,EAAE,QAAQ,CAAC;IACnB,iBAAiB,EAAE,iBAAiB,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC;CAChB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,CAKpD;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,GAAG,SAAS,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAQ3F;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAI5E;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAMpF;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAOnE;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACtB,GAAG,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC3B,iBAAiB,CAAC,EAAE,iBAAiB,EACrC,KAAK,CAAC,EAAE,KAAK,GACd,QAAQ,CAMV;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,GAAG,SAAS,CAE/E"}

package/dist/resource/resource.js

@@ -0,0 +1,98 @@
+// Resource utilities for working with Kubernetes resources and protobuf conversion
+import { Resource, Ready } from "../proto/run_function.js";
+/**
+ * Create a new empty DesiredComposed resource
+ */
+export function newDesiredComposed() {
+    return {
+        resource: Resource.fromJSON({}),
+        ready: Ready.READY_UNSPECIFIED,
+    };
+}
+/**
+ * Convert a protobuf Struct to a Kubernetes object (plain JavaScript object)
+ * This is a more efficient conversion that avoids JSON round-trips when possible
+ *
+ * @param struct - The protobuf Struct to convert
+ * @returns A plain JavaScript object representing the Kubernetes resource
+ */
+export function asObject(struct) {
+    if (!struct) {
+        return {};
+    }
+    // The struct is already a plain object in our TypeScript implementation
+    // In the Go SDK, this does actual protobuf conversion
+    return struct;
+}
+/**
+ * Convert a Kubernetes object to a protobuf Struct
+ * This is used when creating Resource objects from plain JavaScript objects
+ *
+ * @param obj - The plain JavaScript object to convert
+ * @returns A protobuf Struct representation
+ */
+export function asStruct(obj) {
+    // In our TypeScript implementation, this is essentially a pass-through
+    // The actual conversion happens in the protobuf serialization layer
+    return obj;
+}
+/**
+ * Helper function for tests: Convert an object to a Struct, panics on failure
+ * Only use this in test code
+ *
+ * @param obj - The object to convert
+ * @returns A Struct representation
+ * @throws Error if conversion fails
+ */
+export function mustStructObject(obj) {
+    try {
+        return asStruct(obj);
+    }
+    catch (error) {
+        throw new Error(`Failed to convert object to struct: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Helper function for tests: Parse a JSON string into a Struct, panics on failure
+ * Only use this in test code
+ *
+ * @param json - The JSON string to parse
+ * @returns A Struct representation
+ * @throws Error if parsing or conversion fails
+ */
+export function mustStructJSON(json) {
+    try {
+        const obj = JSON.parse(json);
+        return asStruct(obj);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse JSON to struct: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Create a Resource from a plain JavaScript object
+ * This is a convenience wrapper around Resource.fromJSON
+ *
+ * @param obj - The resource object
+ * @param connectionDetails - Optional connection details
+ * @param ready - Optional ready status
+ * @returns A Resource
+ */
+export function fromObject(obj, connectionDetails, ready) {
+    return Resource.fromJSON({
+        resource: obj,
+        connectionDetails: connectionDetails || {},
+        ready: ready !== undefined ? ready : Ready.READY_UNSPECIFIED,
+    });
+}
+/**
+ * Get the resource object from a Resource
+ * This extracts the plain JavaScript object from the Resource wrapper
+ *
+ * @param resource - The Resource to extract from
+ * @returns The plain JavaScript object, or undefined if not present
+ */
+export function toObject(resource) {
+    return resource.resource;
+}
+//# sourceMappingURL=resource.js.map

package/dist/resource/resource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.js","sourceRoot":"","sources":["../../src/resource/resource.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AA8B3D;;GAEG;AACH,MAAM,UAAU,kBAAkB;IAC9B,OAAO;QACH,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC/B,KAAK,EAAE,KAAK,CAAC,iBAAiB;KACjC,CAAC;AACN,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAC,MAA0C;IAC/D,IAAI,CAAC,MAAM,EAAE,CAAC;QACV,OAAO,EAAE,CAAC;IACd,CAAC;IAED,wEAAwE;IACxE,sDAAsD;IACtD,OAAO,MAAM,CAAC;AAClB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAC,GAA2B;IAChD,uEAAuE;IACvE,oEAAoE;IACpE,OAAO,GAAG,CAAC;AACf,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAA2B;IACxD,IAAI,CAAC;QACD,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CAAC,uCAAuC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACrH,CAAC;AACL,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY;IACvC,IAAI,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC7B,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CAAC,mCAAmC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACjH,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,UAAU,CACtB,GAA2B,EAC3B,iBAAqC,EACrC,KAAa;IAEb,OAAO,QAAQ,CAAC,QAAQ,CAAC;QACrB,QAAQ,EAAE,GAAG;QACb,iBAAiB,EAAE,iBAAiB,IAAI,EAAE;QAC1C,KAAK,EAAE,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,iBAAiB;KAC/D,CAAC,CAAC;AACP,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAC,QAAkB;IACvC,OAAO,QAAQ,CAAC,QAAQ,CAAC;AAC7B,CAAC"}

package/dist/response/response.d.ts

@@ -0,0 +1,273 @@
+/**
+ * Response utilities for working with RunFunctionResponse
+ *
+ * This module provides helper functions to build and manipulate RunFunctionResponse objects,
+ * including setting desired state, managing results, handling context, and working with
+ * composite resources and their status.
+ */
+import { Resource, RunFunctionRequest, RunFunctionResponse, Ready } from "../proto/run_function.js";
+import { Duration } from "../proto/google/protobuf/duration.js";
+/**
+ * Default time-to-live for function responses (60 seconds).
+ * Crossplane will call the function again when the TTL expires.
+ */
+declare const DEFAULT_TTL: Duration;
+export { DEFAULT_TTL };
+/**
+ * Bootstrap a response from a request.
+ *
+ * This function creates a new RunFunctionResponse with the request's tag automatically
+ * copied, and initializes the desired state from the request. Using this function is
+ * the recommended pattern to ensure proper response initialization.
+ *
+ * The response will:
+ * - Copy the request's tag to the response metadata
+ * - Initialize the desired state from the request (or create empty if not present)
+ * - Set the TTL (time-to-live) for caching
+ * - Initialize empty results and conditions arrays
+ *
+ * @param req - The RunFunctionRequest to bootstrap from
+ * @param ttl - Optional time-to-live duration (defaults to 60 seconds)
+ * @returns A new RunFunctionResponse initialized from the request
+ *
+ * @example
+ * ```typescript
+ * async RunFunction(req: RunFunctionRequest): Promise<RunFunctionResponse> {
+ *   let rsp = to(req);
+ *   // Add your logic here
+ *   normal(rsp, "Processing complete");
+ *   return rsp;
+ * }
+ * ```
+ */
+export declare function to(req: RunFunctionRequest, ttl?: Duration): RunFunctionResponse;
+type NamedResource = {
+    name: string;
+    resource: Resource;
+};
+/**
+ * Update a map of desired composed resources by adding or updating a named resource.
+ *
+ * This is a helper function to add a single resource to a map of composed resources.
+ * It's useful when building up desired resources before calling setDesiredComposedResources.
+ *
+ * @param cds - The current map of composed resources
+ * @param res - The named resource to add or update
+ * @returns The updated map of composed resources
+ *
+ * @example
+ * ```typescript
+ * let dcds = getDesiredComposedResources(req);
+ * dcds = updateDesiredComposedResources(dcds, {
+ *   name: "my-bucket",
+ *   resource: Resource.fromJSON({ resource: bucketConfig })
+ * });
+ * rsp = setDesiredComposedResources(rsp, dcds);
+ * ```
+ */
+export declare function updateDesiredComposedResources(cds: {
+    [key: string]: Resource;
+}, res: NamedResource): {
+    [key: string]: Resource;
+};
+/**
+ * Add a fatal result to the response.
+ *
+ * Fatal results cause the function pipeline run to be considered a failure.
+ * Subsequent functions may still run, but the first fatal result will be
+ * returned as an error. Fatal results should be used for errors that prevent
+ * the function from producing valid output.
+ *
+ * @param rsp - The RunFunctionResponse to add the result to
+ * @param message - The error message describing the fatal condition
+ * @returns The updated response
+ *
+ * @example
+ * ```typescript
+ * if (!requiredInput) {
+ *   fatal(rsp, "Required input 'databaseSize' not provided");
+ *   return rsp;
+ * }
+ * ```
+ */
+export declare function fatal(rsp: RunFunctionResponse, message: string): RunFunctionResponse;
+/**
+ * Add a normal result to the response.
+ *
+ * Normal results are informational and emitted as normal events and debug logs
+ * associated with the composite resource (XR) or operation. They indicate
+ * successful processing or expected conditions.
+ *
+ * @param rsp - The RunFunctionResponse to add the result to
+ * @param message - The informational message
+ *
+ * @example
+ * ```typescript
+ * normal(rsp, "Successfully configured 3 database replicas");
+ * ```
+ */
+export declare function normal(rsp: RunFunctionResponse, message: string): void;
+/**
+ * Add a warning result to the response.
+ *
+ * Warning results are non-fatal issues that should be brought to attention.
+ * The entire pipeline will run to completion, but warning events and debug logs
+ * will be emitted. Use warnings for recoverable issues or deprecated usage.
+ *
+ * @param rsp - The RunFunctionResponse to add the result to
+ * @param message - The warning message
+ *
+ * @example
+ * ```typescript
+ * if (input.legacyFormat) {
+ *   warning(rsp, "Using deprecated input format, please migrate to new format");
+ * }
+ * ```
+ */
+export declare function warning(rsp: RunFunctionResponse, message: string): void;
+/**
+ * Set the desired composed resources in the response.
+ *
+ * This function sets or merges the desired composed resources in the response.
+ * It uses deep merge to combine new resources with any existing resources,
+ * allowing functions to add or modify resources while preserving those set
+ * by previous functions in the pipeline.
+ *
+ * If the desired state or resources map don't exist, they will be initialized.
+ *
+ * @param rsp - The RunFunctionResponse to update
+ * @param dcds - A map of resource names to Resource objects to set as desired
+ * @returns The updated response
+ *
+ * @example
+ * ```typescript
+ * const dcds = getDesiredComposedResources(req);
+ * dcds["my-deployment"] = Resource.fromJSON({
+ *   resource: { apiVersion: "apps/v1", kind: "Deployment", ... }
+ * });
+ * rsp = setDesiredComposedResources(rsp, dcds);
+ * ```
+ */
+export declare function setDesiredComposedResources(rsp: RunFunctionResponse, dcds: {
+    [key: string]: Resource;
+}): RunFunctionResponse;
+/**
+ * Update a resource by merging source into target.
+ *
+ * This function performs a deep merge of the source resource into the target resource,
+ * allowing you to update specific fields while preserving others. The merge is performed
+ * using the ts-deepmerge library.
+ *
+ * @param src - The source Resource containing updates
+ * @param tgt - The target Resource to be updated
+ * @returns A new Resource with merged values
+ *
+ * @example
+ * ```typescript
+ * const existing = getDesiredComposedResources(req)["my-resource"];
+ * const updated = update(
+ *   Resource.fromJSON({ resource: { spec: { replicas: 5 } } }),
+ *   existing
+ * );
+ * ```
+ */
+export declare function update(src: Resource, tgt: Resource): Resource;
+/**
+ * Set the desired composite resource status.
+ *
+ * This function updates only the status field of the desired composite resource.
+ * It merges the provided status with any existing status, allowing partial updates.
+ * Note that functions should only set the status of composite resources (XRs),
+ * not their metadata or spec.
+ *
+ * @param params - Object containing the response and status to set
+ * @param params.rsp - The RunFunctionResponse to update
+ * @param params.status - The status object to merge into the composite resource
+ * @returns The updated response
+ *
+ * @example
+ * ```typescript
+ * rsp = setDesiredCompositeStatus({
+ *   rsp,
+ *   status: {
+ *     phase: "Ready",
+ *     conditions: [{ type: "Synced", status: "True" }]
+ *   }
+ * });
+ * ```
+ */
+export declare function setDesiredCompositeStatus({ rsp, status }: {
+    rsp: RunFunctionResponse;
+    status: {
+        [key: string]: any;
+    };
+}): RunFunctionResponse;
+/**
+ * Set a context key in the response.
+ *
+ * Context allows functions to pass arbitrary data to subsequent functions in the
+ * pipeline. The context is initialized if it doesn't exist. Crossplane discards
+ * all context returned by the last function in the pipeline.
+ *
+ * @param rsp - The RunFunctionResponse to update
+ * @param key - The context key to set
+ * @param value - The value to associate with the key (can be any JSON-serializable value)
+ * @returns The updated response
+ *
+ * @example
+ * ```typescript
+ * // Set context for next function in pipeline
+ * rsp = setContextKey(rsp, "database-endpoint", "db.example.com:5432");
+ * rsp = setContextKey(rsp, "connection-config", { host: "db.example.com", port: 5432 });
+ * ```
+ */
+export declare function setContextKey(rsp: RunFunctionResponse, key: string, value: any): RunFunctionResponse;
+/**
+ * Set the desired composite resource in the response.
+ *
+ * This function sets the entire desired composite resource and optionally its ready status.
+ * The ready status can be used to override Crossplane's standard readiness detection,
+ * which normally determines the composite's ready state based on composed resources.
+ *
+ * Note: Ready status is only used for composition functions, not operations.
+ *
+ * @param rsp - The RunFunctionResponse to update
+ * @param resource - The desired composite resource to set
+ * @param ready - Optional ready status (READY_TRUE, READY_FALSE, or READY_UNSPECIFIED)
+ * @returns The updated response
+ *
+ * @example
+ * ```typescript
+ * const composite = getObservedCompositeResource(req);
+ * if (composite) {
+ *   // Modify and set as desired with ready status
+ *   rsp = setDesiredCompositeResource(rsp, composite, Ready.READY_TRUE);
+ * }
+ * ```
+ */
+export declare function setDesiredCompositeResource(rsp: RunFunctionResponse, resource: Resource, ready?: Ready): RunFunctionResponse;
+/**
+ * Set the function output in the response.
+ *
+ * Function output is specific to operation functions. The output must be a
+ * JSON-serializable object. Composite resources (XRs) will discard any function
+ * output, as it's only used by operations.
+ *
+ * @param rsp - The RunFunctionResponse to update
+ * @param output - The output object to set (must be JSON-serializable)
+ * @returns The updated response
+ *
+ * @example
+ * ```typescript
+ * // For operation functions
+ * rsp = setOutput(rsp, {
+ *   resourcesCreated: 5,
+ *   status: "success",
+ *   details: { timestamp: new Date().toISOString() }
+ * });
+ * ```
+ */
+export declare function setOutput(rsp: RunFunctionResponse, output: {
+    [key: string]: any;
+}): RunFunctionResponse;
+//# sourceMappingURL=response.d.ts.map

package/dist/response/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/response/response.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,QAAQ,EACR,kBAAkB,EAClB,mBAAmB,EAEnB,KAAK,EACN,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,QAAQ,EAAE,MAAM,sCAAsC,CAAC;AAGhE;;;GAGG;AACH,QAAA,MAAM,WAAW,EAAE,QAAoC,CAAC;AAExD,OAAO,EAAE,WAAW,EAAE,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,EAAE,CAAC,GAAG,EAAE,kBAAkB,EAAE,GAAG,CAAC,EAAE,QAAQ,GAAG,mBAAmB,CAsB/E;AAED,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,EAChC,GAAG,EAAE,aAAa,GACjB;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,CAG7B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,KAAK,CACnB,GAAG,EAAE,mBAAmB,EACxB,OAAO,EAAE,MAAM,GACd,mBAAmB,CAQrB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,QAO/D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,QAOhE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,mBAAmB,EACxB,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,GAChC,mBAAmB,CAYrB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,GAAG,QAAQ,CAE7D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,yBAAyB,CACzC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE;IAAE,GAAG,EAAE,mBAAmB,CAAC;IAAC,MAAM,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KAAE,CAAC;CAAE,GAC5E,mBAAmB,CAOrB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,mBAAmB,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,mBAAmB,CAMpG;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,mBAAmB,EACxB,QAAQ,EAAE,QAAQ,EAClB,KAAK,CAAC,EAAE,KAAK,GACZ,mBAAmB,CAcrB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,mBAAmB,EAAE,MAAM,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,GAAG,mBAAmB,CAGvG"}