@membranehq/sdk 0.4.0 → 0.5.0

package/dist/bundle.js

@@ -6779,505 +6779,6 @@
 	    };
 	};
 
-	const POPUP_ELEMENT_ID = '__integration-app-popup';
-	const CONTAINER_ELEMENT_ID = '__integration-app-container';
-	const CONTAINER_ELEMENT_CLASS = '__integration-app-container';
-	const CONTAINER_ELEMENT_CLASS__LOADER = '__integration-app-container__loader';
-	const BODY_CLASS = '__integration-app-open';
-	const STYLES_ELEMENT_ID = '__integration-app-embed-styles';
-	let IFRAME_START_SHOW_LOADER_TIME = 0;
-	let IFRAME_SHOW_LOADER_TIMEOUT_ID;
-	const IFRAME_SHOW_LOADER_MINIMAL_TIME = 500;
-	const IFRAME_LAYOUT_SHIFT_TIME = 300;
-	function showIframeLoader() {
-	    const container = getContainer();
-	    container === null || container === void 0 ? void 0 : container.classList.add(CONTAINER_ELEMENT_CLASS__LOADER);
-	    IFRAME_START_SHOW_LOADER_TIME = Date.now();
-	}
-	function hideIframeLoader(waitLayoutShift = IFRAME_LAYOUT_SHIFT_TIME) {
-	    if (IFRAME_SHOW_LOADER_TIMEOUT_ID) {
-	        clearTimeout(IFRAME_SHOW_LOADER_TIMEOUT_ID);
-	    }
-	    const delta = Date.now() - IFRAME_START_SHOW_LOADER_TIME;
-	    if (delta >= IFRAME_SHOW_LOADER_MINIMAL_TIME) {
-	        setTimeout(() => {
-	            const container = getContainer();
-	            container === null || container === void 0 ? void 0 : container.classList.remove(CONTAINER_ELEMENT_CLASS__LOADER);
-	            IFRAME_START_SHOW_LOADER_TIME = 0;
-	        }, waitLayoutShift);
-	        return;
-	    }
-	    else {
-	        const waitLayoutShift = delta >= IFRAME_LAYOUT_SHIFT_TIME ? 0 : IFRAME_LAYOUT_SHIFT_TIME - delta;
-	        const timeoutTime = IFRAME_SHOW_LOADER_MINIMAL_TIME - delta;
-	        IFRAME_SHOW_LOADER_TIMEOUT_ID = setTimeout(() => {
-	            hideIframeLoader(waitLayoutShift);
-	        }, timeoutTime);
-	        return;
-	    }
-	}
-	async function openIframe(uri, callbacks = {}, { mountTargetSelector } = {}) {
-	    close();
-	    init(mountTargetSelector);
-	    return new Promise((resolve) => {
-	        function complete(callback) {
-	            close(callback);
-	            resolve();
-	        }
-	        function doOpen() {
-	            const iframe = document.createElement('iframe');
-	            iframe.src = uri;
-	            iframe.id = POPUP_ELEMENT_ID;
-	            iframe.onload = () => {
-	                hideIframeLoader();
-	            };
-	            if (!!getContainer()) {
-	                document.body.classList.add(BODY_CLASS);
-	                showIframeLoader();
-	                appendToContainer(iframe);
-	                handleIframeUnmount(iframe);
-	                connectToChild({
-	                    iframe,
-	                    methods: {
-	                        ...callbacks,
-	                        handshake: (...args) => {
-	                            var _a;
-	                            hideIframeLoader();
-	                            (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.handshake) === null || _a === void 0 ? void 0 : _a.call(callbacks, ...args);
-	                        },
-	                        close: () => complete(callbacks.onClose),
-	                    },
-	                });
-	            }
-	            else {
-	                throw Error('Membrane container element not found. Was it manually removed?');
-	            }
-	        }
-	        if (document.readyState === 'complete' || document.readyState === 'interactive') {
-	            doOpen();
-	        }
-	        else {
-	            document.addEventListener('DOMContentLoaded', () => {
-	                doOpen();
-	            });
-	        }
-	    });
-	}
-	function close(callback) {
-	    document.body.classList.remove(BODY_CLASS);
-	    if (!!getContainer()) {
-	        deleteContainer();
-	        if (callback) {
-	            callback();
-	        }
-	    }
-	}
-	function init(mountTargetSelector) {
-	    var _a;
-	    injectStyles(mountTargetSelector);
-	    if (!!getContainer()) {
-	        return;
-	    }
-	    const container = createContainer();
-	    if (mountTargetSelector && document.querySelector(mountTargetSelector)) {
-	        (_a = document.querySelector(mountTargetSelector)) === null || _a === void 0 ? void 0 : _a.appendChild(container);
-	    }
-	    else {
-	        document.body.appendChild(container);
-	    }
-	}
-	function injectStyles(mountTargetSelector) {
-	    const hasCustomMountTarget = Boolean(mountTargetSelector && document.querySelector(mountTargetSelector));
-	    const styles = [
-	        `.${CONTAINER_ELEMENT_CLASS}:empty {
-      display: none;
-    }`,
-	        hasCustomMountTarget
-	            ? `.${CONTAINER_ELEMENT_CLASS} {
-        inset: 0;
-        background: rgba(0, 0, 0, 0);
-        transition: background 0.2s ease-out;
-        display: flex;
-        justify-content: center;
-        align-items: center;
-        width: 100%;
-        height: 100%;
-      }`
-	            : `.${CONTAINER_ELEMENT_CLASS} {
-        position: fixed;
-        inset: 0;
-        z-index: 2147483647;
-        display: flex;
-        justify-content: center;
-        align-items: center;
-        pointer-events: auto;
-        background: rgba(0, 0, 0, 0);
-        transition: background 0.2s ease-out;
-      }`,
-	        `.${CONTAINER_ELEMENT_CLASS}.${CONTAINER_ELEMENT_CLASS__LOADER} {
-      background: rgba(0, 0, 0, 0.8);
-    }`,
-	        `.${CONTAINER_ELEMENT_CLASS}.${CONTAINER_ELEMENT_CLASS__LOADER}::before {
-      ${hasCustomMountTarget ? 'position: absolute;' : ''}
-      content: "";
-      width: 5rem;
-      height: 4rem;
-      background-image: url('data:image/svg+xml,%3Csvg viewBox="0 0 32 22" fill="%23000" xmlns="http://www.w3.org/2000/svg" %3E%3Cdefs%3E%3Cmask id="a"%3E%3Crect width="100%25" height="100%25" fill="%23fff" /%3E%3Cpath d="M11.8 13.12a3 3 0 0 1 0-4.24l7.08-7.07a3 3 0 0 1 4.24 0l7.07 7.07a3 3 0 0 1 0 4.24l-7.07 7.07a3 3 0 0 1-4.24 0l-7.07-7.07Z"%3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 21 11" to="-360 21 11" /%3E%3C/path%3E%3C/mask%3E%3Cmask id="b"%3E%3Crect width="100%25" height="100%25" fill="%23fff"/%3E%3Cpath fill-rule="evenodd" clip-rule="evenodd" d="M1.8 8.88a3 3 0 0 0 0 4.24l7.08 7.07a3 3 0 0 0 4.24 0l7.07-7.07a3 3 0 0 0 0-4.24L13.12 1.8a3 3 0 0 0-4.24 0L1.8 8.88Zm.71.7a2 2 0 0 0 0 2.83L9.6 19.5a2 2 0 0 0 2.82 0l7.08-7.08a2 2 0 0 0 0-2.82l-7.1-7.1a2 2 0 0 0-2.82 0L2.5 9.6Z" %3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 11 11" to="720 11 11" /%3E%3C/path%3E%3C/mask%3E%3C/defs%3E%3Cg mask="url(%23a)"%3E%3Cpath fill-rule="evenodd" clip-rule="evenodd" d="M1.8 8.88a3 3 0 0 0 0 4.24l7.08 7.07a3 3 0 0 0 4.24 0l7.07-7.07a3 3 0 0 0 0-4.24L13.12 1.8a3 3 0 0 0-4.24 0L1.8 8.88Zm.71.7a2 2 0 0 0 0 2.83L9.6 19.5a2 2 0 0 0 2.82 0l7.08-7.08a2 2 0 0 0 0-2.82l-7.1-7.1a2 2 0 0 0-2.82 0L2.5 9.6Z"%0A%3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 11 11" to="720 11 11" /%3E%3C/path%3E%3C/g%3E%3Cg mask="url(%23b)"%3E%3Cpath d="M11.8 13.12a3 3 0 0 1 0-4.24l7.08-7.07a3 3 0 0 1 4.24 0l7.07 7.07a3 3 0 0 1 0 4.24l-7.07 7.07a3 3 0 0 1-4.24 0l-7.07-7.07Z"%3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 21 11" to="-360 21 11" /%3E%3C/path%3E%3C/g%3E%3C/svg%3E');
-      background-size: contain;
-      background-repeat: no-repeat;
-      background-position: center;
-      filter: invert(1);
-    }`,
-	        `.${CONTAINER_ELEMENT_CLASS} iframe {
-      ${hasCustomMountTarget ? '' : 'position: absolute;'}
-      width: 100%;
-      height: 100%;
-      border-width: 0;
-
-      /* fix transparent bg, because iframe document has light scheme */
-      color-scheme: light;
-    }`,
-	        `.${CONTAINER_ELEMENT_CLASS}.${CONTAINER_ELEMENT_CLASS__LOADER} iframe {
-      visibility: hidden;
-    }`,
-	        !hasCustomMountTarget
-	            ? `body.${BODY_CLASS} {
-          overflow: hidden;
-        }`
-	            : '',
-	    ];
-	    let styleElement = document.getElementById(STYLES_ELEMENT_ID);
-	    if (!styleElement) {
-	        styleElement = document.createElement('style');
-	        styleElement.id = STYLES_ELEMENT_ID;
-	        styleElement.type = 'text/css';
-	        document.head.appendChild(styleElement);
-	    }
-	    styleElement.textContent = styles.join('\n');
-	}
-	function removeInjectedStyles() {
-	    const stylesElement = document.getElementById(STYLES_ELEMENT_ID);
-	    if (stylesElement) {
-	        stylesElement.remove();
-	    }
-	}
-	function createContainer() {
-	    const container = document.createElement('div');
-	    container.id = CONTAINER_ELEMENT_ID;
-	    container.classList.add(CONTAINER_ELEMENT_CLASS);
-	    return container;
-	}
-	function getContainer() {
-	    return document.getElementById(CONTAINER_ELEMENT_ID);
-	}
-	function appendToContainer(el) {
-	    const container = getContainer();
-	    container === null || container === void 0 ? void 0 : container.appendChild(el);
-	}
-	function deleteContainer() {
-	    const container = getContainer();
-	    if (container) {
-	        container.remove();
-	    }
-	    removeInjectedStyles();
-	}
-	function handleIframeUnmount(iframe) {
-	    const observer = new MutationObserver((mutationsList) => {
-	        for (const mutation of mutationsList) {
-	            for (const removedNode of mutation.removedNodes) {
-	                if (removedNode instanceof HTMLElement && removedNode.id === POPUP_ELEMENT_ID) {
-	                    observer.disconnect();
-	                    deleteContainer();
-	                    return;
-	                }
-	            }
-	        }
-	    });
-	    const parent = iframe.parentNode;
-	    if (parent) {
-	        observer.observe(parent, {
-	            childList: true,
-	        });
-	    }
-	    else {
-	        console.warn(`iframe with ID "${POPUP_ELEMENT_ID}" has no parent node`);
-	    }
-	}
-
-	class ConnectionLevelElementAccessor {
-	    constructor(client, connectionSelector, selector, elementKey, query) {
-	        this.client = client;
-	        this.connectionSelector = connectionSelector;
-	        this.selector = selector;
-	        this.elementKey = elementKey;
-	        this.query = query;
-	        this.endpoint = `/connections/${this.connectionSelector}/${elementKey}/${selector}`;
-	    }
-	    uri(path = '', query = {}) {
-	        return this.endpoint + path + '?' + qs.stringify({ ...this.query, ...query });
-	    }
-	    getUniqueIdentifier() {
-	        return this.endpoint;
-	    }
-	    async get(query = {}) {
-	        return this.client.get(this.uri('', query));
-	    }
-	    async create() {
-	        return this.client.put(this.uri());
-	    }
-	    async patch(data) {
-	        return this.client.patch(this.uri(), data);
-	    }
-	    async put(data) {
-	        return this.client.put(this.uri(), data);
-	    }
-	    async archive() {
-	        return this.client.delete(this.uri());
-	    }
-	    async reset() {
-	        return this.client.post(this.uri('/reset'));
-	    }
-	    async setup() {
-	        return this.client.post(this.uri('/setup'));
-	    }
-	}
-	class ConnectionLevelElementsListAccessor {
-	    constructor(client, connectionSelector, elementKey) {
-	        this.client = client;
-	        this.connectionSelector = connectionSelector;
-	        this.elementKey = elementKey;
-	    }
-	    async list(query) {
-	        const endpoint = `/connections/${this.connectionSelector}/${this.elementKey}?${qs.stringify(query !== null && query !== void 0 ? query : {})}`;
-	        return this.client.get(endpoint);
-	    }
-	}
-
-	class ActionInstancesAccessor extends ElementInstanceListAccessor {
-	    constructor(client) {
-	        super(client, 'action-instances');
-	    }
-	}
-	class ActionInstanceAccessor extends ElementInstanceAccessor {
-	    constructor(client, selector) {
-	        super({
-	            client,
-	            instancePath: 'action-instance',
-	            selector,
-	        });
-	        this.client = client;
-	    }
-	    async setup() {
-	        await this.client.post(this.getPath('setup'));
-	    }
-	    async reset() {
-	        await this.client.post(this.getPath('reset'));
-	    }
-	    async run(input) {
-	        return this.client.post(this.getPath('run'), input);
-	    }
-	    async open({ onClose = () => { } } = {}) {
-	        const id = await this.getId();
-	        const uri = await this.client.getEmbedUri(`action-instances/${id}/configuration`);
-	        return openIframe(uri, { onClose });
-	    }
-	}
-	class ConnectionLevelActionAccessor extends ConnectionLevelElementAccessor {
-	    constructor(client, connectionSelector, actionSelector, query) {
-	        super(client, connectionSelector, actionSelector, 'actions', query);
-	        this.client = client;
-	        this.connectionSelector = connectionSelector;
-	        this.actionSelector = actionSelector;
-	        this.query = query;
-	    }
-	    async run(input) {
-	        return this.client.post(this.uri('/run'), input);
-	    }
-	}
-	class ConnectionLevelActionsAccessor extends ConnectionLevelElementsListAccessor {
-	    constructor(client, connectionSelector) {
-	        super(client, connectionSelector, 'actions');
-	        this.client = client;
-	        this.connectionSelector = connectionSelector;
-	    }
-	}
-
-	class DataSourcesAccessor extends ElementListAccessor {
-	    constructor(client) {
-	        super(client, 'data-sources');
-	    }
-	}
-	class DataSourceAccessor extends ElementAccessor {
-	    constructor(client, selector) {
-	        super({
-	            client,
-	            selector,
-	            path: 'data-source',
-	        });
-	    }
-	    async apply(integrationKeys) {
-	        return await this.options.client.post(this.getPath('apply'), {
-	            integrationKeys,
-	        });
-	    }
-	    async setup() {
-	        await this.options.client.post(this.getPath('setup'));
-	    }
-	    async reset() {
-	        return await this.options.client.post(this.getPath('reset'));
-	    }
-	}
-	class DataSourceInstancesAccessor extends ElementInstanceListAccessor {
-	    constructor(client) {
-	        super(client, 'data-source-instances');
-	    }
-	}
-	class DataSourceInstanceAccessor extends ElementInstanceAccessor {
-	    constructor(client, selector) {
-	        super({
-	            client,
-	            instancePath: 'data-source-instance',
-	            selector,
-	        });
-	        this.client = client;
-	    }
-	    async setup() {
-	        await this.client.post(this.getPath('setup'));
-	    }
-	    async reset() {
-	        await this.client.post(this.getPath('reset'));
-	    }
-	    async openConfiguration({ onClose = () => { } } = {}) {
-	        const id = await this.getId();
-	        const uri = await this.client.getEmbedUri(`data-source-instances/${id}/configuration`);
-	        return openIframe(uri, {
-	            onClose,
-	        });
-	    }
-	    async unifiedFieldsToNative(unifiedFields) {
-	        return this.client.post(this.getPath('unified-fields-to-native'), unifiedFields);
-	    }
-	    async getCollection() {
-	        return this.client.get(this.getPath('collection'));
-	    }
-	    async listRecords(request = {}) {
-	        return this.client.post(this.getPath('collection/list'), request);
-	    }
-	    async matchRecord(request) {
-	        return this.client.post(this.getPath('collection/match'), request);
-	    }
-	    async searchRecords(request) {
-	        return this.client.post(this.getPath('collection/search'), request);
-	    }
-	    async findRecordById(request) {
-	        const data = typeof request === 'string' ? { id: request } : request;
-	        return this.client.post(this.getPath('collection/find-by-id'), data);
-	    }
-	    async createRecord(request) {
-	        return this.client.post(this.getPath('collection/create'), request);
-	    }
-	    async updateRecord(request) {
-	        return this.client.post(this.getPath(`collection/update`), request);
-	    }
-	    async deleteRecord(request) {
-	        const data = typeof request === 'string' ? { id: request } : request;
-	        return this.client.post(this.getPath(`collection/delete`), data);
-	    }
-	    async findRecords(request = {}) {
-	        return this.client.post(this.getPath('collection/find'), request);
-	    }
-	}
-	class IntegrationLevelDataSourceAccessor extends IntegrationLevelElementAccessor {
-	    constructor(client, integrationSelector, dataSourceSelector) {
-	        super(client, integrationSelector, dataSourceSelector, 'data-sources');
-	        this.client = client;
-	        this.integrationSelector = integrationSelector;
-	        this.dataSourceSelector = dataSourceSelector;
-	    }
-	}
-	class IntegrationLevelDataSourcesListAccessor extends IntegrationLevelElementsListAccessor {
-	    constructor(client, integrationSelector) {
-	        super(client, integrationSelector, 'data-sources');
-	        this.client = client;
-	        this.integrationSelector = integrationSelector;
-	    }
-	}
-	class ConnectionLevelDataSourceAccessor extends ConnectionLevelElementAccessor {
-	    constructor(client, connectionSelector, dataSourceSelector, query) {
-	        super(client, connectionSelector, dataSourceSelector, 'data-sources', query);
-	        this.client = client;
-	        this.connectionSelector = connectionSelector;
-	        this.dataSourceSelector = dataSourceSelector;
-	        this.query = query;
-	    }
-	    async openConfiguration(options) {
-	        var _a;
-	        const instance = await this.get({ autoCreate: true });
-	        const uri = await this.client.getEmbedUri(`data-source-instances/${instance.id}/configuration`);
-	        const onClose = (_a = options === null || options === void 0 ? void 0 : options.onClose) !== null && _a !== void 0 ? _a : (() => { });
-	        return openIframe(uri, { onClose });
-	    }
-	}
-	class ConnectionLevelDataSourcesAccessor extends ConnectionLevelElementsListAccessor {
-	    constructor(client, connectionSelector) {
-	        super(client, connectionSelector, 'data-sources');
-	        this.client = client;
-	        this.connectionSelector = connectionSelector;
-	    }
-	}
-
-	class FieldMappingInstancesAccessor extends ElementInstanceListAccessor {
-	    constructor(client) {
-	        super(client, 'field-mapping-instances');
-	    }
-	}
-	class FieldMappingInstanceAccessor extends ElementInstanceAccessor {
-	    constructor(client, selector) {
-	        super({
-	            client,
-	            instancePath: 'field-mapping-instance',
-	            selector,
-	        });
-	        this.client = client;
-	    }
-	    async setup() {
-	        const id = await this.getId();
-	        return this.client.post(`/field-mapping-instances/${id}/setup`);
-	    }
-	    async reset() {
-	        const id = await this.getId();
-	        return this.client.post(`/field-mapping-instances/${id}/reset`);
-	    }
-	    async openConfiguration({ onClose = () => { } } = {}) {
-	        const id = await this.getId();
-	        const uri = await this.client.getEmbedUri(`field-mapping-instances/${id}/configuration`);
-	        return openIframe(uri, {
-	            onClose,
-	        });
-	    }
-	}
-	class ConnectionLevelFieldMappingAccessor extends ConnectionLevelElementAccessor {
-	    constructor(client, connectionSelector, fieldMappingSelector, query) {
-	        super(client, connectionSelector, fieldMappingSelector, 'field-mappings', query);
-	        this.client = client;
-	        this.connectionSelector = connectionSelector;
-	        this.fieldMappingSelector = fieldMappingSelector;
-	        this.query = query;
-	    }
-	    async openConfiguration({ onClose } = {}) {
-	        const instance = await this.get({ autoCreate: true });
-	        const uri = await this.client.getEmbedUri(`field-mapping-instances/${instance.id}/configuration`);
-	        return openIframe(uri, { onClose: onClose !== null && onClose !== void 0 ? onClose : (() => { }) });
-	    }
-	}
-	class ConnectionLevelFieldMappingsAccessor extends ConnectionLevelElementsListAccessor {
-	    constructor(client, connectionSelector) {
-	        super(client, connectionSelector, 'field-mappings');
-	        this.client = client;
-	        this.connectionSelector = connectionSelector;
-	    }
-	}
-
 	var util;
 	(function (util) {
 	    util.assertEqual = (_) => { };
@@ -9195,22 +8696,158 @@
 	            message: errorUtil.toString(message),
 	        });
 	    }
-	    nonnegative(message) {
+	    nonnegative(message) {
+	        return this._addCheck({
+	            kind: "min",
+	            value: BigInt(0),
+	            inclusive: true,
+	            message: errorUtil.toString(message),
+	        });
+	    }
+	    multipleOf(value, message) {
+	        return this._addCheck({
+	            kind: "multipleOf",
+	            value,
+	            message: errorUtil.toString(message),
+	        });
+	    }
+	    get minValue() {
+	        let min = null;
+	        for (const ch of this._def.checks) {
+	            if (ch.kind === "min") {
+	                if (min === null || ch.value > min)
+	                    min = ch.value;
+	            }
+	        }
+	        return min;
+	    }
+	    get maxValue() {
+	        let max = null;
+	        for (const ch of this._def.checks) {
+	            if (ch.kind === "max") {
+	                if (max === null || ch.value < max)
+	                    max = ch.value;
+	            }
+	        }
+	        return max;
+	    }
+	}
+	ZodBigInt.create = (params) => {
+	    return new ZodBigInt({
+	        checks: [],
+	        typeName: ZodFirstPartyTypeKind.ZodBigInt,
+	        coerce: params?.coerce ?? false,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodBoolean extends ZodType {
+	    _parse(input) {
+	        if (this._def.coerce) {
+	            input.data = Boolean(input.data);
+	        }
+	        const parsedType = this._getType(input);
+	        if (parsedType !== ZodParsedType.boolean) {
+	            const ctx = this._getOrReturnCtx(input);
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.invalid_type,
+	                expected: ZodParsedType.boolean,
+	                received: ctx.parsedType,
+	            });
+	            return INVALID;
+	        }
+	        return OK(input.data);
+	    }
+	}
+	ZodBoolean.create = (params) => {
+	    return new ZodBoolean({
+	        typeName: ZodFirstPartyTypeKind.ZodBoolean,
+	        coerce: params?.coerce || false,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodDate extends ZodType {
+	    _parse(input) {
+	        if (this._def.coerce) {
+	            input.data = new Date(input.data);
+	        }
+	        const parsedType = this._getType(input);
+	        if (parsedType !== ZodParsedType.date) {
+	            const ctx = this._getOrReturnCtx(input);
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.invalid_type,
+	                expected: ZodParsedType.date,
+	                received: ctx.parsedType,
+	            });
+	            return INVALID;
+	        }
+	        if (Number.isNaN(input.data.getTime())) {
+	            const ctx = this._getOrReturnCtx(input);
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.invalid_date,
+	            });
+	            return INVALID;
+	        }
+	        const status = new ParseStatus();
+	        let ctx = undefined;
+	        for (const check of this._def.checks) {
+	            if (check.kind === "min") {
+	                if (input.data.getTime() < check.value) {
+	                    ctx = this._getOrReturnCtx(input, ctx);
+	                    addIssueToContext(ctx, {
+	                        code: ZodIssueCode.too_small,
+	                        message: check.message,
+	                        inclusive: true,
+	                        exact: false,
+	                        minimum: check.value,
+	                        type: "date",
+	                    });
+	                    status.dirty();
+	                }
+	            }
+	            else if (check.kind === "max") {
+	                if (input.data.getTime() > check.value) {
+	                    ctx = this._getOrReturnCtx(input, ctx);
+	                    addIssueToContext(ctx, {
+	                        code: ZodIssueCode.too_big,
+	                        message: check.message,
+	                        inclusive: true,
+	                        exact: false,
+	                        maximum: check.value,
+	                        type: "date",
+	                    });
+	                    status.dirty();
+	                }
+	            }
+	            else {
+	                util.assertNever(check);
+	            }
+	        }
+	        return {
+	            status: status.value,
+	            value: new Date(input.data.getTime()),
+	        };
+	    }
+	    _addCheck(check) {
+	        return new ZodDate({
+	            ...this._def,
+	            checks: [...this._def.checks, check],
+	        });
+	    }
+	    min(minDate, message) {
 	        return this._addCheck({
 	            kind: "min",
-	            value: BigInt(0),
-	            inclusive: true,
+	            value: minDate.getTime(),
 	            message: errorUtil.toString(message),
 	        });
 	    }
-	    multipleOf(value, message) {
+	    max(maxDate, message) {
 	        return this._addCheck({
-	            kind: "multipleOf",
-	            value,
+	            kind: "max",
+	            value: maxDate.getTime(),
 	            message: errorUtil.toString(message),
 	        });
 	    }
-	    get minValue() {
+	    get minDate() {
 	        let min = null;
 	        for (const ch of this._def.checks) {
 	            if (ch.kind === "min") {
@@ -9218,9 +8855,9 @@
 	                    min = ch.value;
 	            }
 	        }
-	        return min;
+	        return min != null ? new Date(min) : null;
 	    }
-	    get maxValue() {
+	    get maxDate() {
 	        let max = null;
 	        for (const ch of this._def.checks) {
 	            if (ch.kind === "max") {
@@ -9228,1838 +8865,2322 @@
 	                    max = ch.value;
 	            }
 	        }
-	        return max;
+	        return max != null ? new Date(max) : null;
 	    }
 	}
-	ZodBigInt.create = (params) => {
-	    return new ZodBigInt({
+	ZodDate.create = (params) => {
+	    return new ZodDate({
 	        checks: [],
-	        typeName: ZodFirstPartyTypeKind.ZodBigInt,
-	        coerce: params?.coerce ?? false,
+	        coerce: params?.coerce || false,
+	        typeName: ZodFirstPartyTypeKind.ZodDate,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodSymbol extends ZodType {
+	    _parse(input) {
+	        const parsedType = this._getType(input);
+	        if (parsedType !== ZodParsedType.symbol) {
+	            const ctx = this._getOrReturnCtx(input);
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.invalid_type,
+	                expected: ZodParsedType.symbol,
+	                received: ctx.parsedType,
+	            });
+	            return INVALID;
+	        }
+	        return OK(input.data);
+	    }
+	}
+	ZodSymbol.create = (params) => {
+	    return new ZodSymbol({
+	        typeName: ZodFirstPartyTypeKind.ZodSymbol,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodUndefined extends ZodType {
+	    _parse(input) {
+	        const parsedType = this._getType(input);
+	        if (parsedType !== ZodParsedType.undefined) {
+	            const ctx = this._getOrReturnCtx(input);
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.invalid_type,
+	                expected: ZodParsedType.undefined,
+	                received: ctx.parsedType,
+	            });
+	            return INVALID;
+	        }
+	        return OK(input.data);
+	    }
+	}
+	ZodUndefined.create = (params) => {
+	    return new ZodUndefined({
+	        typeName: ZodFirstPartyTypeKind.ZodUndefined,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodNull extends ZodType {
+	    _parse(input) {
+	        const parsedType = this._getType(input);
+	        if (parsedType !== ZodParsedType.null) {
+	            const ctx = this._getOrReturnCtx(input);
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.invalid_type,
+	                expected: ZodParsedType.null,
+	                received: ctx.parsedType,
+	            });
+	            return INVALID;
+	        }
+	        return OK(input.data);
+	    }
+	}
+	ZodNull.create = (params) => {
+	    return new ZodNull({
+	        typeName: ZodFirstPartyTypeKind.ZodNull,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodAny extends ZodType {
+	    constructor() {
+	        super(...arguments);
+	        // to prevent instances of other classes from extending ZodAny. this causes issues with catchall in ZodObject.
+	        this._any = true;
+	    }
+	    _parse(input) {
+	        return OK(input.data);
+	    }
+	}
+	ZodAny.create = (params) => {
+	    return new ZodAny({
+	        typeName: ZodFirstPartyTypeKind.ZodAny,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodUnknown extends ZodType {
+	    constructor() {
+	        super(...arguments);
+	        // required
+	        this._unknown = true;
+	    }
+	    _parse(input) {
+	        return OK(input.data);
+	    }
+	}
+	ZodUnknown.create = (params) => {
+	    return new ZodUnknown({
+	        typeName: ZodFirstPartyTypeKind.ZodUnknown,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodNever extends ZodType {
+	    _parse(input) {
+	        const ctx = this._getOrReturnCtx(input);
+	        addIssueToContext(ctx, {
+	            code: ZodIssueCode.invalid_type,
+	            expected: ZodParsedType.never,
+	            received: ctx.parsedType,
+	        });
+	        return INVALID;
+	    }
+	}
+	ZodNever.create = (params) => {
+	    return new ZodNever({
+	        typeName: ZodFirstPartyTypeKind.ZodNever,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodVoid extends ZodType {
+	    _parse(input) {
+	        const parsedType = this._getType(input);
+	        if (parsedType !== ZodParsedType.undefined) {
+	            const ctx = this._getOrReturnCtx(input);
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.invalid_type,
+	                expected: ZodParsedType.void,
+	                received: ctx.parsedType,
+	            });
+	            return INVALID;
+	        }
+	        return OK(input.data);
+	    }
+	}
+	ZodVoid.create = (params) => {
+	    return new ZodVoid({
+	        typeName: ZodFirstPartyTypeKind.ZodVoid,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodArray extends ZodType {
+	    _parse(input) {
+	        const { ctx, status } = this._processInputParams(input);
+	        const def = this._def;
+	        if (ctx.parsedType !== ZodParsedType.array) {
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.invalid_type,
+	                expected: ZodParsedType.array,
+	                received: ctx.parsedType,
+	            });
+	            return INVALID;
+	        }
+	        if (def.exactLength !== null) {
+	            const tooBig = ctx.data.length > def.exactLength.value;
+	            const tooSmall = ctx.data.length < def.exactLength.value;
+	            if (tooBig || tooSmall) {
+	                addIssueToContext(ctx, {
+	                    code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
+	                    minimum: (tooSmall ? def.exactLength.value : undefined),
+	                    maximum: (tooBig ? def.exactLength.value : undefined),
+	                    type: "array",
+	                    inclusive: true,
+	                    exact: true,
+	                    message: def.exactLength.message,
+	                });
+	                status.dirty();
+	            }
+	        }
+	        if (def.minLength !== null) {
+	            if (ctx.data.length < def.minLength.value) {
+	                addIssueToContext(ctx, {
+	                    code: ZodIssueCode.too_small,
+	                    minimum: def.minLength.value,
+	                    type: "array",
+	                    inclusive: true,
+	                    exact: false,
+	                    message: def.minLength.message,
+	                });
+	                status.dirty();
+	            }
+	        }
+	        if (def.maxLength !== null) {
+	            if (ctx.data.length > def.maxLength.value) {
+	                addIssueToContext(ctx, {
+	                    code: ZodIssueCode.too_big,
+	                    maximum: def.maxLength.value,
+	                    type: "array",
+	                    inclusive: true,
+	                    exact: false,
+	                    message: def.maxLength.message,
+	                });
+	                status.dirty();
+	            }
+	        }
+	        if (ctx.common.async) {
+	            return Promise.all([...ctx.data].map((item, i) => {
+	                return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
+	            })).then((result) => {
+	                return ParseStatus.mergeArray(status, result);
+	            });
+	        }
+	        const result = [...ctx.data].map((item, i) => {
+	            return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
+	        });
+	        return ParseStatus.mergeArray(status, result);
+	    }
+	    get element() {
+	        return this._def.type;
+	    }
+	    min(minLength, message) {
+	        return new ZodArray({
+	            ...this._def,
+	            minLength: { value: minLength, message: errorUtil.toString(message) },
+	        });
+	    }
+	    max(maxLength, message) {
+	        return new ZodArray({
+	            ...this._def,
+	            maxLength: { value: maxLength, message: errorUtil.toString(message) },
+	        });
+	    }
+	    length(len, message) {
+	        return new ZodArray({
+	            ...this._def,
+	            exactLength: { value: len, message: errorUtil.toString(message) },
+	        });
+	    }
+	    nonempty(message) {
+	        return this.min(1, message);
+	    }
+	}
+	ZodArray.create = (schema, params) => {
+	    return new ZodArray({
+	        type: schema,
+	        minLength: null,
+	        maxLength: null,
+	        exactLength: null,
+	        typeName: ZodFirstPartyTypeKind.ZodArray,
 	        ...processCreateParams(params),
 	    });
 	};
-	class ZodBoolean extends ZodType {
-	    _parse(input) {
-	        if (this._def.coerce) {
-	            input.data = Boolean(input.data);
-	        }
-	        const parsedType = this._getType(input);
-	        if (parsedType !== ZodParsedType.boolean) {
-	            const ctx = this._getOrReturnCtx(input);
-	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.invalid_type,
-	                expected: ZodParsedType.boolean,
-	                received: ctx.parsedType,
-	            });
-	            return INVALID;
+	function deepPartialify(schema) {
+	    if (schema instanceof ZodObject) {
+	        const newShape = {};
+	        for (const key in schema.shape) {
+	            const fieldSchema = schema.shape[key];
+	            newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
 	        }
-	        return OK(input.data);
+	        return new ZodObject({
+	            ...schema._def,
+	            shape: () => newShape,
+	        });
+	    }
+	    else if (schema instanceof ZodArray) {
+	        return new ZodArray({
+	            ...schema._def,
+	            type: deepPartialify(schema.element),
+	        });
+	    }
+	    else if (schema instanceof ZodOptional) {
+	        return ZodOptional.create(deepPartialify(schema.unwrap()));
+	    }
+	    else if (schema instanceof ZodNullable) {
+	        return ZodNullable.create(deepPartialify(schema.unwrap()));
+	    }
+	    else if (schema instanceof ZodTuple) {
+	        return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
+	    }
+	    else {
+	        return schema;
 	    }
 	}
-	ZodBoolean.create = (params) => {
-	    return new ZodBoolean({
-	        typeName: ZodFirstPartyTypeKind.ZodBoolean,
-	        coerce: params?.coerce || false,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodDate extends ZodType {
+	class ZodObject extends ZodType {
+	    constructor() {
+	        super(...arguments);
+	        this._cached = null;
+	        /**
+	         * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
+	         * If you want to pass through unknown properties, use `.passthrough()` instead.
+	         */
+	        this.nonstrict = this.passthrough;
+	        // extend<
+	        //   Augmentation extends ZodRawShape,
+	        //   NewOutput extends util.flatten<{
+	        //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
+	        //       ? Augmentation[k]["_output"]
+	        //       : k extends keyof Output
+	        //       ? Output[k]
+	        //       : never;
+	        //   }>,
+	        //   NewInput extends util.flatten<{
+	        //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
+	        //       ? Augmentation[k]["_input"]
+	        //       : k extends keyof Input
+	        //       ? Input[k]
+	        //       : never;
+	        //   }>
+	        // >(
+	        //   augmentation: Augmentation
+	        // ): ZodObject<
+	        //   extendShape<T, Augmentation>,
+	        //   UnknownKeys,
+	        //   Catchall,
+	        //   NewOutput,
+	        //   NewInput
+	        // > {
+	        //   return new ZodObject({
+	        //     ...this._def,
+	        //     shape: () => ({
+	        //       ...this._def.shape(),
+	        //       ...augmentation,
+	        //     }),
+	        //   }) as any;
+	        // }
+	        /**
+	         * @deprecated Use `.extend` instead
+	         *  */
+	        this.augment = this.extend;
+	    }
+	    _getCached() {
+	        if (this._cached !== null)
+	            return this._cached;
+	        const shape = this._def.shape();
+	        const keys = util.objectKeys(shape);
+	        this._cached = { shape, keys };
+	        return this._cached;
+	    }
 	    _parse(input) {
-	        if (this._def.coerce) {
-	            input.data = new Date(input.data);
-	        }
 	        const parsedType = this._getType(input);
-	        if (parsedType !== ZodParsedType.date) {
+	        if (parsedType !== ZodParsedType.object) {
 	            const ctx = this._getOrReturnCtx(input);
 	            addIssueToContext(ctx, {
 	                code: ZodIssueCode.invalid_type,
-	                expected: ZodParsedType.date,
+	                expected: ZodParsedType.object,
 	                received: ctx.parsedType,
 	            });
 	            return INVALID;
 	        }
-	        if (Number.isNaN(input.data.getTime())) {
-	            const ctx = this._getOrReturnCtx(input);
-	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.invalid_date,
+	        const { status, ctx } = this._processInputParams(input);
+	        const { shape, keys: shapeKeys } = this._getCached();
+	        const extraKeys = [];
+	        if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
+	            for (const key in ctx.data) {
+	                if (!shapeKeys.includes(key)) {
+	                    extraKeys.push(key);
+	                }
+	            }
+	        }
+	        const pairs = [];
+	        for (const key of shapeKeys) {
+	            const keyValidator = shape[key];
+	            const value = ctx.data[key];
+	            pairs.push({
+	                key: { status: "valid", value: key },
+	                value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
+	                alwaysSet: key in ctx.data,
 	            });
-	            return INVALID;
 	        }
-	        const status = new ParseStatus();
-	        let ctx = undefined;
-	        for (const check of this._def.checks) {
-	            if (check.kind === "min") {
-	                if (input.data.getTime() < check.value) {
-	                    ctx = this._getOrReturnCtx(input, ctx);
-	                    addIssueToContext(ctx, {
-	                        code: ZodIssueCode.too_small,
-	                        message: check.message,
-	                        inclusive: true,
-	                        exact: false,
-	                        minimum: check.value,
-	                        type: "date",
+	        if (this._def.catchall instanceof ZodNever) {
+	            const unknownKeys = this._def.unknownKeys;
+	            if (unknownKeys === "passthrough") {
+	                for (const key of extraKeys) {
+	                    pairs.push({
+	                        key: { status: "valid", value: key },
+	                        value: { status: "valid", value: ctx.data[key] },
 	                    });
-	                    status.dirty();
 	                }
 	            }
-	            else if (check.kind === "max") {
-	                if (input.data.getTime() > check.value) {
-	                    ctx = this._getOrReturnCtx(input, ctx);
+	            else if (unknownKeys === "strict") {
+	                if (extraKeys.length > 0) {
 	                    addIssueToContext(ctx, {
-	                        code: ZodIssueCode.too_big,
-	                        message: check.message,
-	                        inclusive: true,
-	                        exact: false,
-	                        maximum: check.value,
-	                        type: "date",
+	                        code: ZodIssueCode.unrecognized_keys,
+	                        keys: extraKeys,
 	                    });
 	                    status.dirty();
 	                }
 	            }
+	            else if (unknownKeys === "strip") ;
 	            else {
-	                util.assertNever(check);
+	                throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
 	            }
 	        }
-	        return {
-	            status: status.value,
-	            value: new Date(input.data.getTime()),
-	        };
+	        else {
+	            // run catchall validation
+	            const catchall = this._def.catchall;
+	            for (const key of extraKeys) {
+	                const value = ctx.data[key];
+	                pairs.push({
+	                    key: { status: "valid", value: key },
+	                    value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key) //, ctx.child(key), value, getParsedType(value)
+	                    ),
+	                    alwaysSet: key in ctx.data,
+	                });
+	            }
+	        }
+	        if (ctx.common.async) {
+	            return Promise.resolve()
+	                .then(async () => {
+	                const syncPairs = [];
+	                for (const pair of pairs) {
+	                    const key = await pair.key;
+	                    const value = await pair.value;
+	                    syncPairs.push({
+	                        key,
+	                        value,
+	                        alwaysSet: pair.alwaysSet,
+	                    });
+	                }
+	                return syncPairs;
+	            })
+	                .then((syncPairs) => {
+	                return ParseStatus.mergeObjectSync(status, syncPairs);
+	            });
+	        }
+	        else {
+	            return ParseStatus.mergeObjectSync(status, pairs);
+	        }
+	    }
+	    get shape() {
+	        return this._def.shape();
+	    }
+	    strict(message) {
+	        errorUtil.errToObj;
+	        return new ZodObject({
+	            ...this._def,
+	            unknownKeys: "strict",
+	            ...(message !== undefined
+	                ? {
+	                    errorMap: (issue, ctx) => {
+	                        const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
+	                        if (issue.code === "unrecognized_keys")
+	                            return {
+	                                message: errorUtil.errToObj(message).message ?? defaultError,
+	                            };
+	                        return {
+	                            message: defaultError,
+	                        };
+	                    },
+	                }
+	                : {}),
+	        });
+	    }
+	    strip() {
+	        return new ZodObject({
+	            ...this._def,
+	            unknownKeys: "strip",
+	        });
+	    }
+	    passthrough() {
+	        return new ZodObject({
+	            ...this._def,
+	            unknownKeys: "passthrough",
+	        });
 	    }
-	    _addCheck(check) {
-	        return new ZodDate({
+	    // const AugmentFactory =
+	    //   <Def extends ZodObjectDef>(def: Def) =>
+	    //   <Augmentation extends ZodRawShape>(
+	    //     augmentation: Augmentation
+	    //   ): ZodObject<
+	    //     extendShape<ReturnType<Def["shape"]>, Augmentation>,
+	    //     Def["unknownKeys"],
+	    //     Def["catchall"]
+	    //   > => {
+	    //     return new ZodObject({
+	    //       ...def,
+	    //       shape: () => ({
+	    //         ...def.shape(),
+	    //         ...augmentation,
+	    //       }),
+	    //     }) as any;
+	    //   };
+	    extend(augmentation) {
+	        return new ZodObject({
 	            ...this._def,
-	            checks: [...this._def.checks, check],
+	            shape: () => ({
+	                ...this._def.shape(),
+	                ...augmentation,
+	            }),
 	        });
 	    }
-	    min(minDate, message) {
-	        return this._addCheck({
-	            kind: "min",
-	            value: minDate.getTime(),
-	            message: errorUtil.toString(message),
+	    /**
+	     * Prior to zod@1.0.12 there was a bug in the
+	     * inferred type of merged objects. Please
+	     * upgrade if you are experiencing issues.
+	     */
+	    merge(merging) {
+	        const merged = new ZodObject({
+	            unknownKeys: merging._def.unknownKeys,
+	            catchall: merging._def.catchall,
+	            shape: () => ({
+	                ...this._def.shape(),
+	                ...merging._def.shape(),
+	            }),
+	            typeName: ZodFirstPartyTypeKind.ZodObject,
 	        });
+	        return merged;
 	    }
-	    max(maxDate, message) {
-	        return this._addCheck({
-	            kind: "max",
-	            value: maxDate.getTime(),
-	            message: errorUtil.toString(message),
+	    // merge<
+	    //   Incoming extends AnyZodObject,
+	    //   Augmentation extends Incoming["shape"],
+	    //   NewOutput extends {
+	    //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
+	    //       ? Augmentation[k]["_output"]
+	    //       : k extends keyof Output
+	    //       ? Output[k]
+	    //       : never;
+	    //   },
+	    //   NewInput extends {
+	    //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
+	    //       ? Augmentation[k]["_input"]
+	    //       : k extends keyof Input
+	    //       ? Input[k]
+	    //       : never;
+	    //   }
+	    // >(
+	    //   merging: Incoming
+	    // ): ZodObject<
+	    //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
+	    //   Incoming["_def"]["unknownKeys"],
+	    //   Incoming["_def"]["catchall"],
+	    //   NewOutput,
+	    //   NewInput
+	    // > {
+	    //   const merged: any = new ZodObject({
+	    //     unknownKeys: merging._def.unknownKeys,
+	    //     catchall: merging._def.catchall,
+	    //     shape: () =>
+	    //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
+	    //     typeName: ZodFirstPartyTypeKind.ZodObject,
+	    //   }) as any;
+	    //   return merged;
+	    // }
+	    setKey(key, schema) {
+	        return this.augment({ [key]: schema });
+	    }
+	    // merge<Incoming extends AnyZodObject>(
+	    //   merging: Incoming
+	    // ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
+	    // ZodObject<
+	    //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
+	    //   Incoming["_def"]["unknownKeys"],
+	    //   Incoming["_def"]["catchall"]
+	    // > {
+	    //   // const mergedShape = objectUtil.mergeShapes(
+	    //   //   this._def.shape(),
+	    //   //   merging._def.shape()
+	    //   // );
+	    //   const merged: any = new ZodObject({
+	    //     unknownKeys: merging._def.unknownKeys,
+	    //     catchall: merging._def.catchall,
+	    //     shape: () =>
+	    //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
+	    //     typeName: ZodFirstPartyTypeKind.ZodObject,
+	    //   }) as any;
+	    //   return merged;
+	    // }
+	    catchall(index) {
+	        return new ZodObject({
+	            ...this._def,
+	            catchall: index,
 	        });
 	    }
-	    get minDate() {
-	        let min = null;
-	        for (const ch of this._def.checks) {
-	            if (ch.kind === "min") {
-	                if (min === null || ch.value > min)
-	                    min = ch.value;
+	    pick(mask) {
+	        const shape = {};
+	        for (const key of util.objectKeys(mask)) {
+	            if (mask[key] && this.shape[key]) {
+	                shape[key] = this.shape[key];
 	            }
 	        }
-	        return min != null ? new Date(min) : null;
+	        return new ZodObject({
+	            ...this._def,
+	            shape: () => shape,
+	        });
 	    }
-	    get maxDate() {
-	        let max = null;
-	        for (const ch of this._def.checks) {
-	            if (ch.kind === "max") {
-	                if (max === null || ch.value < max)
-	                    max = ch.value;
+	    omit(mask) {
+	        const shape = {};
+	        for (const key of util.objectKeys(this.shape)) {
+	            if (!mask[key]) {
+	                shape[key] = this.shape[key];
 	            }
 	        }
-	        return max != null ? new Date(max) : null;
-	    }
-	}
-	ZodDate.create = (params) => {
-	    return new ZodDate({
-	        checks: [],
-	        coerce: params?.coerce || false,
-	        typeName: ZodFirstPartyTypeKind.ZodDate,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodSymbol extends ZodType {
-	    _parse(input) {
-	        const parsedType = this._getType(input);
-	        if (parsedType !== ZodParsedType.symbol) {
-	            const ctx = this._getOrReturnCtx(input);
-	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.invalid_type,
-	                expected: ZodParsedType.symbol,
-	                received: ctx.parsedType,
-	            });
-	            return INVALID;
-	        }
-	        return OK(input.data);
+	        return new ZodObject({
+	            ...this._def,
+	            shape: () => shape,
+	        });
 	    }
-	}
-	ZodSymbol.create = (params) => {
-	    return new ZodSymbol({
-	        typeName: ZodFirstPartyTypeKind.ZodSymbol,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodUndefined extends ZodType {
-	    _parse(input) {
-	        const parsedType = this._getType(input);
-	        if (parsedType !== ZodParsedType.undefined) {
-	            const ctx = this._getOrReturnCtx(input);
-	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.invalid_type,
-	                expected: ZodParsedType.undefined,
-	                received: ctx.parsedType,
-	            });
-	            return INVALID;
-	        }
-	        return OK(input.data);
+	    /**
+	     * @deprecated
+	     */
+	    deepPartial() {
+	        return deepPartialify(this);
 	    }
-	}
-	ZodUndefined.create = (params) => {
-	    return new ZodUndefined({
-	        typeName: ZodFirstPartyTypeKind.ZodUndefined,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodNull extends ZodType {
-	    _parse(input) {
-	        const parsedType = this._getType(input);
-	        if (parsedType !== ZodParsedType.null) {
-	            const ctx = this._getOrReturnCtx(input);
-	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.invalid_type,
-	                expected: ZodParsedType.null,
-	                received: ctx.parsedType,
-	            });
-	            return INVALID;
+	    partial(mask) {
+	        const newShape = {};
+	        for (const key of util.objectKeys(this.shape)) {
+	            const fieldSchema = this.shape[key];
+	            if (mask && !mask[key]) {
+	                newShape[key] = fieldSchema;
+	            }
+	            else {
+	                newShape[key] = fieldSchema.optional();
+	            }
 	        }
-	        return OK(input.data);
-	    }
-	}
-	ZodNull.create = (params) => {
-	    return new ZodNull({
-	        typeName: ZodFirstPartyTypeKind.ZodNull,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodAny extends ZodType {
-	    constructor() {
-	        super(...arguments);
-	        // to prevent instances of other classes from extending ZodAny. this causes issues with catchall in ZodObject.
-	        this._any = true;
-	    }
-	    _parse(input) {
-	        return OK(input.data);
+	        return new ZodObject({
+	            ...this._def,
+	            shape: () => newShape,
+	        });
 	    }
-	}
-	ZodAny.create = (params) => {
-	    return new ZodAny({
-	        typeName: ZodFirstPartyTypeKind.ZodAny,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodUnknown extends ZodType {
-	    constructor() {
-	        super(...arguments);
-	        // required
-	        this._unknown = true;
+	    required(mask) {
+	        const newShape = {};
+	        for (const key of util.objectKeys(this.shape)) {
+	            if (mask && !mask[key]) {
+	                newShape[key] = this.shape[key];
+	            }
+	            else {
+	                const fieldSchema = this.shape[key];
+	                let newField = fieldSchema;
+	                while (newField instanceof ZodOptional) {
+	                    newField = newField._def.innerType;
+	                }
+	                newShape[key] = newField;
+	            }
+	        }
+	        return new ZodObject({
+	            ...this._def,
+	            shape: () => newShape,
+	        });
 	    }
-	    _parse(input) {
-	        return OK(input.data);
+	    keyof() {
+	        return createZodEnum(util.objectKeys(this.shape));
 	    }
 	}
-	ZodUnknown.create = (params) => {
-	    return new ZodUnknown({
-	        typeName: ZodFirstPartyTypeKind.ZodUnknown,
+	ZodObject.create = (shape, params) => {
+	    return new ZodObject({
+	        shape: () => shape,
+	        unknownKeys: "strip",
+	        catchall: ZodNever.create(),
+	        typeName: ZodFirstPartyTypeKind.ZodObject,
 	        ...processCreateParams(params),
 	    });
 	};
-	class ZodNever extends ZodType {
-	    _parse(input) {
-	        const ctx = this._getOrReturnCtx(input);
-	        addIssueToContext(ctx, {
-	            code: ZodIssueCode.invalid_type,
-	            expected: ZodParsedType.never,
-	            received: ctx.parsedType,
-	        });
-	        return INVALID;
-	    }
-	}
-	ZodNever.create = (params) => {
-	    return new ZodNever({
-	        typeName: ZodFirstPartyTypeKind.ZodNever,
+	ZodObject.strictCreate = (shape, params) => {
+	    return new ZodObject({
+	        shape: () => shape,
+	        unknownKeys: "strict",
+	        catchall: ZodNever.create(),
+	        typeName: ZodFirstPartyTypeKind.ZodObject,
 	        ...processCreateParams(params),
 	    });
 	};
-	class ZodVoid extends ZodType {
-	    _parse(input) {
-	        const parsedType = this._getType(input);
-	        if (parsedType !== ZodParsedType.undefined) {
-	            const ctx = this._getOrReturnCtx(input);
-	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.invalid_type,
-	                expected: ZodParsedType.void,
-	                received: ctx.parsedType,
-	            });
-	            return INVALID;
-	        }
-	        return OK(input.data);
-	    }
-	}
-	ZodVoid.create = (params) => {
-	    return new ZodVoid({
-	        typeName: ZodFirstPartyTypeKind.ZodVoid,
+	ZodObject.lazycreate = (shape, params) => {
+	    return new ZodObject({
+	        shape,
+	        unknownKeys: "strip",
+	        catchall: ZodNever.create(),
+	        typeName: ZodFirstPartyTypeKind.ZodObject,
 	        ...processCreateParams(params),
 	    });
 	};
-	class ZodArray extends ZodType {
+	class ZodUnion extends ZodType {
 	    _parse(input) {
-	        const { ctx, status } = this._processInputParams(input);
-	        const def = this._def;
-	        if (ctx.parsedType !== ZodParsedType.array) {
+	        const { ctx } = this._processInputParams(input);
+	        const options = this._def.options;
+	        function handleResults(results) {
+	            // return first issue-free validation if it exists
+	            for (const result of results) {
+	                if (result.result.status === "valid") {
+	                    return result.result;
+	                }
+	            }
+	            for (const result of results) {
+	                if (result.result.status === "dirty") {
+	                    // add issues from dirty option
+	                    ctx.common.issues.push(...result.ctx.common.issues);
+	                    return result.result;
+	                }
+	            }
+	            // return invalid
+	            const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
 	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.invalid_type,
-	                expected: ZodParsedType.array,
-	                received: ctx.parsedType,
+	                code: ZodIssueCode.invalid_union,
+	                unionErrors,
 	            });
 	            return INVALID;
 	        }
-	        if (def.exactLength !== null) {
-	            const tooBig = ctx.data.length > def.exactLength.value;
-	            const tooSmall = ctx.data.length < def.exactLength.value;
-	            if (tooBig || tooSmall) {
-	                addIssueToContext(ctx, {
-	                    code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
-	                    minimum: (tooSmall ? def.exactLength.value : undefined),
-	                    maximum: (tooBig ? def.exactLength.value : undefined),
-	                    type: "array",
-	                    inclusive: true,
-	                    exact: true,
-	                    message: def.exactLength.message,
-	                });
-	                status.dirty();
-	            }
+	        if (ctx.common.async) {
+	            return Promise.all(options.map(async (option) => {
+	                const childCtx = {
+	                    ...ctx,
+	                    common: {
+	                        ...ctx.common,
+	                        issues: [],
+	                    },
+	                    parent: null,
+	                };
+	                return {
+	                    result: await option._parseAsync({
+	                        data: ctx.data,
+	                        path: ctx.path,
+	                        parent: childCtx,
+	                    }),
+	                    ctx: childCtx,
+	                };
+	            })).then(handleResults);
 	        }
-	        if (def.minLength !== null) {
-	            if (ctx.data.length < def.minLength.value) {
-	                addIssueToContext(ctx, {
-	                    code: ZodIssueCode.too_small,
-	                    minimum: def.minLength.value,
-	                    type: "array",
-	                    inclusive: true,
-	                    exact: false,
-	                    message: def.minLength.message,
+	        else {
+	            let dirty = undefined;
+	            const issues = [];
+	            for (const option of options) {
+	                const childCtx = {
+	                    ...ctx,
+	                    common: {
+	                        ...ctx.common,
+	                        issues: [],
+	                    },
+	                    parent: null,
+	                };
+	                const result = option._parseSync({
+	                    data: ctx.data,
+	                    path: ctx.path,
+	                    parent: childCtx,
 	                });
-	                status.dirty();
+	                if (result.status === "valid") {
+	                    return result;
+	                }
+	                else if (result.status === "dirty" && !dirty) {
+	                    dirty = { result, ctx: childCtx };
+	                }
+	                if (childCtx.common.issues.length) {
+	                    issues.push(childCtx.common.issues);
+	                }
 	            }
-	        }
-	        if (def.maxLength !== null) {
-	            if (ctx.data.length > def.maxLength.value) {
-	                addIssueToContext(ctx, {
-	                    code: ZodIssueCode.too_big,
-	                    maximum: def.maxLength.value,
-	                    type: "array",
-	                    inclusive: true,
-	                    exact: false,
-	                    message: def.maxLength.message,
-	                });
-	                status.dirty();
+	            if (dirty) {
+	                ctx.common.issues.push(...dirty.ctx.common.issues);
+	                return dirty.result;
 	            }
-	        }
-	        if (ctx.common.async) {
-	            return Promise.all([...ctx.data].map((item, i) => {
-	                return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
-	            })).then((result) => {
-	                return ParseStatus.mergeArray(status, result);
+	            const unionErrors = issues.map((issues) => new ZodError(issues));
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.invalid_union,
+	                unionErrors,
 	            });
+	            return INVALID;
 	        }
-	        const result = [...ctx.data].map((item, i) => {
-	            return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
-	        });
-	        return ParseStatus.mergeArray(status, result);
-	    }
-	    get element() {
-	        return this._def.type;
-	    }
-	    min(minLength, message) {
-	        return new ZodArray({
-	            ...this._def,
-	            minLength: { value: minLength, message: errorUtil.toString(message) },
-	        });
-	    }
-	    max(maxLength, message) {
-	        return new ZodArray({
-	            ...this._def,
-	            maxLength: { value: maxLength, message: errorUtil.toString(message) },
-	        });
-	    }
-	    length(len, message) {
-	        return new ZodArray({
-	            ...this._def,
-	            exactLength: { value: len, message: errorUtil.toString(message) },
-	        });
 	    }
-	    nonempty(message) {
-	        return this.min(1, message);
+	    get options() {
+	        return this._def.options;
 	    }
 	}
-	ZodArray.create = (schema, params) => {
-	    return new ZodArray({
-	        type: schema,
-	        minLength: null,
-	        maxLength: null,
-	        exactLength: null,
-	        typeName: ZodFirstPartyTypeKind.ZodArray,
+	ZodUnion.create = (types, params) => {
+	    return new ZodUnion({
+	        options: types,
+	        typeName: ZodFirstPartyTypeKind.ZodUnion,
 	        ...processCreateParams(params),
 	    });
 	};
-	function deepPartialify(schema) {
-	    if (schema instanceof ZodObject) {
-	        const newShape = {};
-	        for (const key in schema.shape) {
-	            const fieldSchema = schema.shape[key];
-	            newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
-	        }
-	        return new ZodObject({
-	            ...schema._def,
-	            shape: () => newShape,
-	        });
-	    }
-	    else if (schema instanceof ZodArray) {
-	        return new ZodArray({
-	            ...schema._def,
-	            type: deepPartialify(schema.element),
-	        });
+	function mergeValues(a, b) {
+	    const aType = getParsedType(a);
+	    const bType = getParsedType(b);
+	    if (a === b) {
+	        return { valid: true, data: a };
 	    }
-	    else if (schema instanceof ZodOptional) {
-	        return ZodOptional.create(deepPartialify(schema.unwrap()));
+	    else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
+	        const bKeys = util.objectKeys(b);
+	        const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
+	        const newObj = { ...a, ...b };
+	        for (const key of sharedKeys) {
+	            const sharedValue = mergeValues(a[key], b[key]);
+	            if (!sharedValue.valid) {
+	                return { valid: false };
+	            }
+	            newObj[key] = sharedValue.data;
+	        }
+	        return { valid: true, data: newObj };
 	    }
-	    else if (schema instanceof ZodNullable) {
-	        return ZodNullable.create(deepPartialify(schema.unwrap()));
+	    else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
+	        if (a.length !== b.length) {
+	            return { valid: false };
+	        }
+	        const newArray = [];
+	        for (let index = 0; index < a.length; index++) {
+	            const itemA = a[index];
+	            const itemB = b[index];
+	            const sharedValue = mergeValues(itemA, itemB);
+	            if (!sharedValue.valid) {
+	                return { valid: false };
+	            }
+	            newArray.push(sharedValue.data);
+	        }
+	        return { valid: true, data: newArray };
 	    }
-	    else if (schema instanceof ZodTuple) {
-	        return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
+	    else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
+	        return { valid: true, data: a };
 	    }
 	    else {
-	        return schema;
+	        return { valid: false };
 	    }
 	}
-	class ZodObject extends ZodType {
-	    constructor() {
-	        super(...arguments);
-	        this._cached = null;
-	        /**
-	         * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
-	         * If you want to pass through unknown properties, use `.passthrough()` instead.
-	         */
-	        this.nonstrict = this.passthrough;
-	        // extend<
-	        //   Augmentation extends ZodRawShape,
-	        //   NewOutput extends util.flatten<{
-	        //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
-	        //       ? Augmentation[k]["_output"]
-	        //       : k extends keyof Output
-	        //       ? Output[k]
-	        //       : never;
-	        //   }>,
-	        //   NewInput extends util.flatten<{
-	        //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
-	        //       ? Augmentation[k]["_input"]
-	        //       : k extends keyof Input
-	        //       ? Input[k]
-	        //       : never;
-	        //   }>
-	        // >(
-	        //   augmentation: Augmentation
-	        // ): ZodObject<
-	        //   extendShape<T, Augmentation>,
-	        //   UnknownKeys,
-	        //   Catchall,
-	        //   NewOutput,
-	        //   NewInput
-	        // > {
-	        //   return new ZodObject({
-	        //     ...this._def,
-	        //     shape: () => ({
-	        //       ...this._def.shape(),
-	        //       ...augmentation,
-	        //     }),
-	        //   }) as any;
-	        // }
-	        /**
-	         * @deprecated Use `.extend` instead
-	         *  */
-	        this.augment = this.extend;
-	    }
-	    _getCached() {
-	        if (this._cached !== null)
-	            return this._cached;
-	        const shape = this._def.shape();
-	        const keys = util.objectKeys(shape);
-	        this._cached = { shape, keys };
-	        return this._cached;
+	class ZodIntersection extends ZodType {
+	    _parse(input) {
+	        const { status, ctx } = this._processInputParams(input);
+	        const handleParsed = (parsedLeft, parsedRight) => {
+	            if (isAborted(parsedLeft) || isAborted(parsedRight)) {
+	                return INVALID;
+	            }
+	            const merged = mergeValues(parsedLeft.value, parsedRight.value);
+	            if (!merged.valid) {
+	                addIssueToContext(ctx, {
+	                    code: ZodIssueCode.invalid_intersection_types,
+	                });
+	                return INVALID;
+	            }
+	            if (isDirty(parsedLeft) || isDirty(parsedRight)) {
+	                status.dirty();
+	            }
+	            return { status: status.value, value: merged.data };
+	        };
+	        if (ctx.common.async) {
+	            return Promise.all([
+	                this._def.left._parseAsync({
+	                    data: ctx.data,
+	                    path: ctx.path,
+	                    parent: ctx,
+	                }),
+	                this._def.right._parseAsync({
+	                    data: ctx.data,
+	                    path: ctx.path,
+	                    parent: ctx,
+	                }),
+	            ]).then(([left, right]) => handleParsed(left, right));
+	        }
+	        else {
+	            return handleParsed(this._def.left._parseSync({
+	                data: ctx.data,
+	                path: ctx.path,
+	                parent: ctx,
+	            }), this._def.right._parseSync({
+	                data: ctx.data,
+	                path: ctx.path,
+	                parent: ctx,
+	            }));
+	        }
 	    }
+	}
+	ZodIntersection.create = (left, right, params) => {
+	    return new ZodIntersection({
+	        left: left,
+	        right: right,
+	        typeName: ZodFirstPartyTypeKind.ZodIntersection,
+	        ...processCreateParams(params),
+	    });
+	};
+	// type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
+	class ZodTuple extends ZodType {
 	    _parse(input) {
-	        const parsedType = this._getType(input);
-	        if (parsedType !== ZodParsedType.object) {
-	            const ctx = this._getOrReturnCtx(input);
+	        const { status, ctx } = this._processInputParams(input);
+	        if (ctx.parsedType !== ZodParsedType.array) {
 	            addIssueToContext(ctx, {
 	                code: ZodIssueCode.invalid_type,
-	                expected: ZodParsedType.object,
+	                expected: ZodParsedType.array,
 	                received: ctx.parsedType,
 	            });
 	            return INVALID;
 	        }
-	        const { status, ctx } = this._processInputParams(input);
-	        const { shape, keys: shapeKeys } = this._getCached();
-	        const extraKeys = [];
-	        if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
-	            for (const key in ctx.data) {
-	                if (!shapeKeys.includes(key)) {
-	                    extraKeys.push(key);
-	                }
-	            }
-	        }
-	        const pairs = [];
-	        for (const key of shapeKeys) {
-	            const keyValidator = shape[key];
-	            const value = ctx.data[key];
-	            pairs.push({
-	                key: { status: "valid", value: key },
-	                value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
-	                alwaysSet: key in ctx.data,
+	        if (ctx.data.length < this._def.items.length) {
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.too_small,
+	                minimum: this._def.items.length,
+	                inclusive: true,
+	                exact: false,
+	                type: "array",
 	            });
+	            return INVALID;
 	        }
-	        if (this._def.catchall instanceof ZodNever) {
-	            const unknownKeys = this._def.unknownKeys;
-	            if (unknownKeys === "passthrough") {
-	                for (const key of extraKeys) {
-	                    pairs.push({
-	                        key: { status: "valid", value: key },
-	                        value: { status: "valid", value: ctx.data[key] },
-	                    });
-	                }
-	            }
-	            else if (unknownKeys === "strict") {
-	                if (extraKeys.length > 0) {
-	                    addIssueToContext(ctx, {
-	                        code: ZodIssueCode.unrecognized_keys,
-	                        keys: extraKeys,
-	                    });
-	                    status.dirty();
-	                }
-	            }
-	            else if (unknownKeys === "strip") ;
-	            else {
-	                throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
-	            }
-	        }
-	        else {
-	            // run catchall validation
-	            const catchall = this._def.catchall;
-	            for (const key of extraKeys) {
-	                const value = ctx.data[key];
-	                pairs.push({
-	                    key: { status: "valid", value: key },
-	                    value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key) //, ctx.child(key), value, getParsedType(value)
-	                    ),
-	                    alwaysSet: key in ctx.data,
-	                });
-	            }
+	        const rest = this._def.rest;
+	        if (!rest && ctx.data.length > this._def.items.length) {
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.too_big,
+	                maximum: this._def.items.length,
+	                inclusive: true,
+	                exact: false,
+	                type: "array",
+	            });
+	            status.dirty();
 	        }
+	        const items = [...ctx.data]
+	            .map((item, itemIndex) => {
+	            const schema = this._def.items[itemIndex] || this._def.rest;
+	            if (!schema)
+	                return null;
+	            return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
+	        })
+	            .filter((x) => !!x); // filter nulls
 	        if (ctx.common.async) {
-	            return Promise.resolve()
-	                .then(async () => {
-	                const syncPairs = [];
-	                for (const pair of pairs) {
-	                    const key = await pair.key;
-	                    const value = await pair.value;
-	                    syncPairs.push({
-	                        key,
-	                        value,
-	                        alwaysSet: pair.alwaysSet,
-	                    });
-	                }
-	                return syncPairs;
-	            })
-	                .then((syncPairs) => {
-	                return ParseStatus.mergeObjectSync(status, syncPairs);
+	            return Promise.all(items).then((results) => {
+	                return ParseStatus.mergeArray(status, results);
 	            });
 	        }
 	        else {
-	            return ParseStatus.mergeObjectSync(status, pairs);
+	            return ParseStatus.mergeArray(status, items);
 	        }
 	    }
-	    get shape() {
-	        return this._def.shape();
-	    }
-	    strict(message) {
-	        errorUtil.errToObj;
-	        return new ZodObject({
-	            ...this._def,
-	            unknownKeys: "strict",
-	            ...(message !== undefined
-	                ? {
-	                    errorMap: (issue, ctx) => {
-	                        const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
-	                        if (issue.code === "unrecognized_keys")
-	                            return {
-	                                message: errorUtil.errToObj(message).message ?? defaultError,
-	                            };
-	                        return {
-	                            message: defaultError,
-	                        };
-	                    },
-	                }
-	                : {}),
-	        });
-	    }
-	    strip() {
-	        return new ZodObject({
-	            ...this._def,
-	            unknownKeys: "strip",
-	        });
+	    get items() {
+	        return this._def.items;
 	    }
-	    passthrough() {
-	        return new ZodObject({
+	    rest(rest) {
+	        return new ZodTuple({
 	            ...this._def,
-	            unknownKeys: "passthrough",
+	            rest,
 	        });
 	    }
-	    // const AugmentFactory =
-	    //   <Def extends ZodObjectDef>(def: Def) =>
-	    //   <Augmentation extends ZodRawShape>(
-	    //     augmentation: Augmentation
-	    //   ): ZodObject<
-	    //     extendShape<ReturnType<Def["shape"]>, Augmentation>,
-	    //     Def["unknownKeys"],
-	    //     Def["catchall"]
-	    //   > => {
-	    //     return new ZodObject({
-	    //       ...def,
-	    //       shape: () => ({
-	    //         ...def.shape(),
-	    //         ...augmentation,
-	    //       }),
-	    //     }) as any;
-	    //   };
-	    extend(augmentation) {
-	        return new ZodObject({
-	            ...this._def,
-	            shape: () => ({
-	                ...this._def.shape(),
-	                ...augmentation,
-	            }),
-	        });
+	}
+	ZodTuple.create = (schemas, params) => {
+	    if (!Array.isArray(schemas)) {
+	        throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
 	    }
-	    /**
-	     * Prior to zod@1.0.12 there was a bug in the
-	     * inferred type of merged objects. Please
-	     * upgrade if you are experiencing issues.
-	     */
-	    merge(merging) {
-	        const merged = new ZodObject({
-	            unknownKeys: merging._def.unknownKeys,
-	            catchall: merging._def.catchall,
-	            shape: () => ({
-	                ...this._def.shape(),
-	                ...merging._def.shape(),
-	            }),
-	            typeName: ZodFirstPartyTypeKind.ZodObject,
-	        });
-	        return merged;
+	    return new ZodTuple({
+	        items: schemas,
+	        typeName: ZodFirstPartyTypeKind.ZodTuple,
+	        rest: null,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodMap extends ZodType {
+	    get keySchema() {
+	        return this._def.keyType;
 	    }
-	    // merge<
-	    //   Incoming extends AnyZodObject,
-	    //   Augmentation extends Incoming["shape"],
-	    //   NewOutput extends {
-	    //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
-	    //       ? Augmentation[k]["_output"]
-	    //       : k extends keyof Output
-	    //       ? Output[k]
-	    //       : never;
-	    //   },
-	    //   NewInput extends {
-	    //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
-	    //       ? Augmentation[k]["_input"]
-	    //       : k extends keyof Input
-	    //       ? Input[k]
-	    //       : never;
-	    //   }
-	    // >(
-	    //   merging: Incoming
-	    // ): ZodObject<
-	    //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
-	    //   Incoming["_def"]["unknownKeys"],
-	    //   Incoming["_def"]["catchall"],
-	    //   NewOutput,
-	    //   NewInput
-	    // > {
-	    //   const merged: any = new ZodObject({
-	    //     unknownKeys: merging._def.unknownKeys,
-	    //     catchall: merging._def.catchall,
-	    //     shape: () =>
-	    //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
-	    //     typeName: ZodFirstPartyTypeKind.ZodObject,
-	    //   }) as any;
-	    //   return merged;
-	    // }
-	    setKey(key, schema) {
-	        return this.augment({ [key]: schema });
+	    get valueSchema() {
+	        return this._def.valueType;
 	    }
-	    // merge<Incoming extends AnyZodObject>(
-	    //   merging: Incoming
-	    // ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
-	    // ZodObject<
-	    //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
-	    //   Incoming["_def"]["unknownKeys"],
-	    //   Incoming["_def"]["catchall"]
-	    // > {
-	    //   // const mergedShape = objectUtil.mergeShapes(
-	    //   //   this._def.shape(),
-	    //   //   merging._def.shape()
-	    //   // );
-	    //   const merged: any = new ZodObject({
-	    //     unknownKeys: merging._def.unknownKeys,
-	    //     catchall: merging._def.catchall,
-	    //     shape: () =>
-	    //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
-	    //     typeName: ZodFirstPartyTypeKind.ZodObject,
-	    //   }) as any;
-	    //   return merged;
-	    // }
-	    catchall(index) {
-	        return new ZodObject({
-	            ...this._def,
-	            catchall: index,
+	    _parse(input) {
+	        const { status, ctx } = this._processInputParams(input);
+	        if (ctx.parsedType !== ZodParsedType.map) {
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.invalid_type,
+	                expected: ZodParsedType.map,
+	                received: ctx.parsedType,
+	            });
+	            return INVALID;
+	        }
+	        const keyType = this._def.keyType;
+	        const valueType = this._def.valueType;
+	        const pairs = [...ctx.data.entries()].map(([key, value], index) => {
+	            return {
+	                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
+	                value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"])),
+	            };
 	        });
+	        if (ctx.common.async) {
+	            const finalMap = new Map();
+	            return Promise.resolve().then(async () => {
+	                for (const pair of pairs) {
+	                    const key = await pair.key;
+	                    const value = await pair.value;
+	                    if (key.status === "aborted" || value.status === "aborted") {
+	                        return INVALID;
+	                    }
+	                    if (key.status === "dirty" || value.status === "dirty") {
+	                        status.dirty();
+	                    }
+	                    finalMap.set(key.value, value.value);
+	                }
+	                return { status: status.value, value: finalMap };
+	            });
+	        }
+	        else {
+	            const finalMap = new Map();
+	            for (const pair of pairs) {
+	                const key = pair.key;
+	                const value = pair.value;
+	                if (key.status === "aborted" || value.status === "aborted") {
+	                    return INVALID;
+	                }
+	                if (key.status === "dirty" || value.status === "dirty") {
+	                    status.dirty();
+	                }
+	                finalMap.set(key.value, value.value);
+	            }
+	            return { status: status.value, value: finalMap };
+	        }
 	    }
-	    pick(mask) {
-	        const shape = {};
-	        for (const key of util.objectKeys(mask)) {
-	            if (mask[key] && this.shape[key]) {
-	                shape[key] = this.shape[key];
+	}
+	ZodMap.create = (keyType, valueType, params) => {
+	    return new ZodMap({
+	        valueType,
+	        keyType,
+	        typeName: ZodFirstPartyTypeKind.ZodMap,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodSet extends ZodType {
+	    _parse(input) {
+	        const { status, ctx } = this._processInputParams(input);
+	        if (ctx.parsedType !== ZodParsedType.set) {
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.invalid_type,
+	                expected: ZodParsedType.set,
+	                received: ctx.parsedType,
+	            });
+	            return INVALID;
+	        }
+	        const def = this._def;
+	        if (def.minSize !== null) {
+	            if (ctx.data.size < def.minSize.value) {
+	                addIssueToContext(ctx, {
+	                    code: ZodIssueCode.too_small,
+	                    minimum: def.minSize.value,
+	                    type: "set",
+	                    inclusive: true,
+	                    exact: false,
+	                    message: def.minSize.message,
+	                });
+	                status.dirty();
+	            }
+	        }
+	        if (def.maxSize !== null) {
+	            if (ctx.data.size > def.maxSize.value) {
+	                addIssueToContext(ctx, {
+	                    code: ZodIssueCode.too_big,
+	                    maximum: def.maxSize.value,
+	                    type: "set",
+	                    inclusive: true,
+	                    exact: false,
+	                    message: def.maxSize.message,
+	                });
+	                status.dirty();
 	            }
 	        }
-	        return new ZodObject({
+	        const valueType = this._def.valueType;
+	        function finalizeSet(elements) {
+	            const parsedSet = new Set();
+	            for (const element of elements) {
+	                if (element.status === "aborted")
+	                    return INVALID;
+	                if (element.status === "dirty")
+	                    status.dirty();
+	                parsedSet.add(element.value);
+	            }
+	            return { status: status.value, value: parsedSet };
+	        }
+	        const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
+	        if (ctx.common.async) {
+	            return Promise.all(elements).then((elements) => finalizeSet(elements));
+	        }
+	        else {
+	            return finalizeSet(elements);
+	        }
+	    }
+	    min(minSize, message) {
+	        return new ZodSet({
 	            ...this._def,
-	            shape: () => shape,
+	            minSize: { value: minSize, message: errorUtil.toString(message) },
 	        });
 	    }
-	    omit(mask) {
-	        const shape = {};
-	        for (const key of util.objectKeys(this.shape)) {
-	            if (!mask[key]) {
-	                shape[key] = this.shape[key];
-	            }
-	        }
-	        return new ZodObject({
+	    max(maxSize, message) {
+	        return new ZodSet({
 	            ...this._def,
-	            shape: () => shape,
+	            maxSize: { value: maxSize, message: errorUtil.toString(message) },
 	        });
 	    }
-	    /**
-	     * @deprecated
-	     */
-	    deepPartial() {
-	        return deepPartialify(this);
+	    size(size, message) {
+	        return this.min(size, message).max(size, message);
 	    }
-	    partial(mask) {
-	        const newShape = {};
-	        for (const key of util.objectKeys(this.shape)) {
-	            const fieldSchema = this.shape[key];
-	            if (mask && !mask[key]) {
-	                newShape[key] = fieldSchema;
-	            }
-	            else {
-	                newShape[key] = fieldSchema.optional();
-	            }
+	    nonempty(message) {
+	        return this.min(1, message);
+	    }
+	}
+	ZodSet.create = (valueType, params) => {
+	    return new ZodSet({
+	        valueType,
+	        minSize: null,
+	        maxSize: null,
+	        typeName: ZodFirstPartyTypeKind.ZodSet,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodFunction extends ZodType {
+	    constructor() {
+	        super(...arguments);
+	        this.validate = this.implement;
+	    }
+	    _parse(input) {
+	        const { ctx } = this._processInputParams(input);
+	        if (ctx.parsedType !== ZodParsedType.function) {
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.invalid_type,
+	                expected: ZodParsedType.function,
+	                received: ctx.parsedType,
+	            });
+	            return INVALID;
 	        }
-	        return new ZodObject({
+	        function makeArgsIssue(args, error) {
+	            return makeIssue({
+	                data: args,
+	                path: ctx.path,
+	                errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), errorMap].filter((x) => !!x),
+	                issueData: {
+	                    code: ZodIssueCode.invalid_arguments,
+	                    argumentsError: error,
+	                },
+	            });
+	        }
+	        function makeReturnsIssue(returns, error) {
+	            return makeIssue({
+	                data: returns,
+	                path: ctx.path,
+	                errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), errorMap].filter((x) => !!x),
+	                issueData: {
+	                    code: ZodIssueCode.invalid_return_type,
+	                    returnTypeError: error,
+	                },
+	            });
+	        }
+	        const params = { errorMap: ctx.common.contextualErrorMap };
+	        const fn = ctx.data;
+	        if (this._def.returns instanceof ZodPromise) {
+	            // Would love a way to avoid disabling this rule, but we need
+	            // an alias (using an arrow function was what caused 2651).
+	            // eslint-disable-next-line @typescript-eslint/no-this-alias
+	            const me = this;
+	            return OK(async function (...args) {
+	                const error = new ZodError([]);
+	                const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
+	                    error.addIssue(makeArgsIssue(args, e));
+	                    throw error;
+	                });
+	                const result = await Reflect.apply(fn, this, parsedArgs);
+	                const parsedReturns = await me._def.returns._def.type
+	                    .parseAsync(result, params)
+	                    .catch((e) => {
+	                    error.addIssue(makeReturnsIssue(result, e));
+	                    throw error;
+	                });
+	                return parsedReturns;
+	            });
+	        }
+	        else {
+	            // Would love a way to avoid disabling this rule, but we need
+	            // an alias (using an arrow function was what caused 2651).
+	            // eslint-disable-next-line @typescript-eslint/no-this-alias
+	            const me = this;
+	            return OK(function (...args) {
+	                const parsedArgs = me._def.args.safeParse(args, params);
+	                if (!parsedArgs.success) {
+	                    throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
+	                }
+	                const result = Reflect.apply(fn, this, parsedArgs.data);
+	                const parsedReturns = me._def.returns.safeParse(result, params);
+	                if (!parsedReturns.success) {
+	                    throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
+	                }
+	                return parsedReturns.data;
+	            });
+	        }
+	    }
+	    parameters() {
+	        return this._def.args;
+	    }
+	    returnType() {
+	        return this._def.returns;
+	    }
+	    args(...items) {
+	        return new ZodFunction({
 	            ...this._def,
-	            shape: () => newShape,
+	            args: ZodTuple.create(items).rest(ZodUnknown.create()),
 	        });
 	    }
-	    required(mask) {
-	        const newShape = {};
-	        for (const key of util.objectKeys(this.shape)) {
-	            if (mask && !mask[key]) {
-	                newShape[key] = this.shape[key];
-	            }
-	            else {
-	                const fieldSchema = this.shape[key];
-	                let newField = fieldSchema;
-	                while (newField instanceof ZodOptional) {
-	                    newField = newField._def.innerType;
-	                }
-	                newShape[key] = newField;
-	            }
-	        }
-	        return new ZodObject({
+	    returns(returnType) {
+	        return new ZodFunction({
 	            ...this._def,
-	            shape: () => newShape,
+	            returns: returnType,
 	        });
 	    }
-	    keyof() {
-	        return createZodEnum(util.objectKeys(this.shape));
+	    implement(func) {
+	        const validatedFunc = this.parse(func);
+	        return validatedFunc;
+	    }
+	    strictImplement(func) {
+	        const validatedFunc = this.parse(func);
+	        return validatedFunc;
+	    }
+	    static create(args, returns, params) {
+	        return new ZodFunction({
+	            args: (args ? args : ZodTuple.create([]).rest(ZodUnknown.create())),
+	            returns: returns || ZodUnknown.create(),
+	            typeName: ZodFirstPartyTypeKind.ZodFunction,
+	            ...processCreateParams(params),
+	        });
 	    }
 	}
-	ZodObject.create = (shape, params) => {
-	    return new ZodObject({
-	        shape: () => shape,
-	        unknownKeys: "strip",
-	        catchall: ZodNever.create(),
-	        typeName: ZodFirstPartyTypeKind.ZodObject,
+	class ZodLazy extends ZodType {
+	    get schema() {
+	        return this._def.getter();
+	    }
+	    _parse(input) {
+	        const { ctx } = this._processInputParams(input);
+	        const lazySchema = this._def.getter();
+	        return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
+	    }
+	}
+	ZodLazy.create = (getter, params) => {
+	    return new ZodLazy({
+	        getter: getter,
+	        typeName: ZodFirstPartyTypeKind.ZodLazy,
 	        ...processCreateParams(params),
 	    });
 	};
-	ZodObject.strictCreate = (shape, params) => {
-	    return new ZodObject({
-	        shape: () => shape,
-	        unknownKeys: "strict",
-	        catchall: ZodNever.create(),
-	        typeName: ZodFirstPartyTypeKind.ZodObject,
+	class ZodLiteral extends ZodType {
+	    _parse(input) {
+	        if (input.data !== this._def.value) {
+	            const ctx = this._getOrReturnCtx(input);
+	            addIssueToContext(ctx, {
+	                received: ctx.data,
+	                code: ZodIssueCode.invalid_literal,
+	                expected: this._def.value,
+	            });
+	            return INVALID;
+	        }
+	        return { status: "valid", value: input.data };
+	    }
+	    get value() {
+	        return this._def.value;
+	    }
+	}
+	ZodLiteral.create = (value, params) => {
+	    return new ZodLiteral({
+	        value: value,
+	        typeName: ZodFirstPartyTypeKind.ZodLiteral,
 	        ...processCreateParams(params),
 	    });
 	};
-	ZodObject.lazycreate = (shape, params) => {
-	    return new ZodObject({
-	        shape,
-	        unknownKeys: "strip",
-	        catchall: ZodNever.create(),
-	        typeName: ZodFirstPartyTypeKind.ZodObject,
+	function createZodEnum(values, params) {
+	    return new ZodEnum({
+	        values,
+	        typeName: ZodFirstPartyTypeKind.ZodEnum,
 	        ...processCreateParams(params),
 	    });
-	};
-	class ZodUnion extends ZodType {
+	}
+	class ZodEnum extends ZodType {
 	    _parse(input) {
-	        const { ctx } = this._processInputParams(input);
-	        const options = this._def.options;
-	        function handleResults(results) {
-	            // return first issue-free validation if it exists
-	            for (const result of results) {
-	                if (result.result.status === "valid") {
-	                    return result.result;
-	                }
-	            }
-	            for (const result of results) {
-	                if (result.result.status === "dirty") {
-	                    // add issues from dirty option
-	                    ctx.common.issues.push(...result.ctx.common.issues);
-	                    return result.result;
-	                }
-	            }
-	            // return invalid
-	            const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
+	        if (typeof input.data !== "string") {
+	            const ctx = this._getOrReturnCtx(input);
+	            const expectedValues = this._def.values;
+	            addIssueToContext(ctx, {
+	                expected: util.joinValues(expectedValues),
+	                received: ctx.parsedType,
+	                code: ZodIssueCode.invalid_type,
+	            });
+	            return INVALID;
+	        }
+	        if (!this._cache) {
+	            this._cache = new Set(this._def.values);
+	        }
+	        if (!this._cache.has(input.data)) {
+	            const ctx = this._getOrReturnCtx(input);
+	            const expectedValues = this._def.values;
+	            addIssueToContext(ctx, {
+	                received: ctx.data,
+	                code: ZodIssueCode.invalid_enum_value,
+	                options: expectedValues,
+	            });
+	            return INVALID;
+	        }
+	        return OK(input.data);
+	    }
+	    get options() {
+	        return this._def.values;
+	    }
+	    get enum() {
+	        const enumValues = {};
+	        for (const val of this._def.values) {
+	            enumValues[val] = val;
+	        }
+	        return enumValues;
+	    }
+	    get Values() {
+	        const enumValues = {};
+	        for (const val of this._def.values) {
+	            enumValues[val] = val;
+	        }
+	        return enumValues;
+	    }
+	    get Enum() {
+	        const enumValues = {};
+	        for (const val of this._def.values) {
+	            enumValues[val] = val;
+	        }
+	        return enumValues;
+	    }
+	    extract(values, newDef = this._def) {
+	        return ZodEnum.create(values, {
+	            ...this._def,
+	            ...newDef,
+	        });
+	    }
+	    exclude(values, newDef = this._def) {
+	        return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
+	            ...this._def,
+	            ...newDef,
+	        });
+	    }
+	}
+	ZodEnum.create = createZodEnum;
+	class ZodNativeEnum extends ZodType {
+	    _parse(input) {
+	        const nativeEnumValues = util.getValidEnumValues(this._def.values);
+	        const ctx = this._getOrReturnCtx(input);
+	        if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
+	            const expectedValues = util.objectValues(nativeEnumValues);
 	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.invalid_union,
-	                unionErrors,
+	                expected: util.joinValues(expectedValues),
+	                received: ctx.parsedType,
+	                code: ZodIssueCode.invalid_type,
 	            });
 	            return INVALID;
 	        }
-	        if (ctx.common.async) {
-	            return Promise.all(options.map(async (option) => {
-	                const childCtx = {
-	                    ...ctx,
-	                    common: {
-	                        ...ctx.common,
-	                        issues: [],
-	                    },
-	                    parent: null,
-	                };
-	                return {
-	                    result: await option._parseAsync({
-	                        data: ctx.data,
-	                        path: ctx.path,
-	                        parent: childCtx,
-	                    }),
-	                    ctx: childCtx,
-	                };
-	            })).then(handleResults);
+	        if (!this._cache) {
+	            this._cache = new Set(util.getValidEnumValues(this._def.values));
 	        }
-	        else {
-	            let dirty = undefined;
-	            const issues = [];
-	            for (const option of options) {
-	                const childCtx = {
-	                    ...ctx,
-	                    common: {
-	                        ...ctx.common,
-	                        issues: [],
-	                    },
-	                    parent: null,
-	                };
-	                const result = option._parseSync({
-	                    data: ctx.data,
-	                    path: ctx.path,
-	                    parent: childCtx,
-	                });
-	                if (result.status === "valid") {
-	                    return result;
-	                }
-	                else if (result.status === "dirty" && !dirty) {
-	                    dirty = { result, ctx: childCtx };
-	                }
-	                if (childCtx.common.issues.length) {
-	                    issues.push(childCtx.common.issues);
-	                }
-	            }
-	            if (dirty) {
-	                ctx.common.issues.push(...dirty.ctx.common.issues);
-	                return dirty.result;
-	            }
-	            const unionErrors = issues.map((issues) => new ZodError(issues));
+	        if (!this._cache.has(input.data)) {
+	            const expectedValues = util.objectValues(nativeEnumValues);
 	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.invalid_union,
-	                unionErrors,
+	                received: ctx.data,
+	                code: ZodIssueCode.invalid_enum_value,
+	                options: expectedValues,
 	            });
 	            return INVALID;
 	        }
+	        return OK(input.data);
 	    }
-	    get options() {
-	        return this._def.options;
+	    get enum() {
+	        return this._def.values;
 	    }
 	}
-	ZodUnion.create = (types, params) => {
-	    return new ZodUnion({
-	        options: types,
-	        typeName: ZodFirstPartyTypeKind.ZodUnion,
+	ZodNativeEnum.create = (values, params) => {
+	    return new ZodNativeEnum({
+	        values: values,
+	        typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
 	        ...processCreateParams(params),
 	    });
 	};
-	function mergeValues(a, b) {
-	    const aType = getParsedType(a);
-	    const bType = getParsedType(b);
-	    if (a === b) {
-	        return { valid: true, data: a };
-	    }
-	    else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
-	        const bKeys = util.objectKeys(b);
-	        const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
-	        const newObj = { ...a, ...b };
-	        for (const key of sharedKeys) {
-	            const sharedValue = mergeValues(a[key], b[key]);
-	            if (!sharedValue.valid) {
-	                return { valid: false };
-	            }
-	            newObj[key] = sharedValue.data;
-	        }
-	        return { valid: true, data: newObj };
+	class ZodPromise extends ZodType {
+	    unwrap() {
+	        return this._def.type;
 	    }
-	    else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
-	        if (a.length !== b.length) {
-	            return { valid: false };
-	        }
-	        const newArray = [];
-	        for (let index = 0; index < a.length; index++) {
-	            const itemA = a[index];
-	            const itemB = b[index];
-	            const sharedValue = mergeValues(itemA, itemB);
-	            if (!sharedValue.valid) {
-	                return { valid: false };
-	            }
-	            newArray.push(sharedValue.data);
+	    _parse(input) {
+	        const { ctx } = this._processInputParams(input);
+	        if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
+	            addIssueToContext(ctx, {
+	                code: ZodIssueCode.invalid_type,
+	                expected: ZodParsedType.promise,
+	                received: ctx.parsedType,
+	            });
+	            return INVALID;
 	        }
-	        return { valid: true, data: newArray };
+	        const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
+	        return OK(promisified.then((data) => {
+	            return this._def.type.parseAsync(data, {
+	                path: ctx.path,
+	                errorMap: ctx.common.contextualErrorMap,
+	            });
+	        }));
 	    }
-	    else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
-	        return { valid: true, data: a };
+	}
+	ZodPromise.create = (schema, params) => {
+	    return new ZodPromise({
+	        type: schema,
+	        typeName: ZodFirstPartyTypeKind.ZodPromise,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodEffects extends ZodType {
+	    innerType() {
+	        return this._def.schema;
 	    }
-	    else {
-	        return { valid: false };
+	    sourceType() {
+	        return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects
+	            ? this._def.schema.sourceType()
+	            : this._def.schema;
 	    }
-	}
-	class ZodIntersection extends ZodType {
 	    _parse(input) {
 	        const { status, ctx } = this._processInputParams(input);
-	        const handleParsed = (parsedLeft, parsedRight) => {
-	            if (isAborted(parsedLeft) || isAborted(parsedRight)) {
-	                return INVALID;
+	        const effect = this._def.effect || null;
+	        const checkCtx = {
+	            addIssue: (arg) => {
+	                addIssueToContext(ctx, arg);
+	                if (arg.fatal) {
+	                    status.abort();
+	                }
+	                else {
+	                    status.dirty();
+	                }
+	            },
+	            get path() {
+	                return ctx.path;
+	            },
+	        };
+	        checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
+	        if (effect.type === "preprocess") {
+	            const processed = effect.transform(ctx.data, checkCtx);
+	            if (ctx.common.async) {
+	                return Promise.resolve(processed).then(async (processed) => {
+	                    if (status.value === "aborted")
+	                        return INVALID;
+	                    const result = await this._def.schema._parseAsync({
+	                        data: processed,
+	                        path: ctx.path,
+	                        parent: ctx,
+	                    });
+	                    if (result.status === "aborted")
+	                        return INVALID;
+	                    if (result.status === "dirty")
+	                        return DIRTY(result.value);
+	                    if (status.value === "dirty")
+	                        return DIRTY(result.value);
+	                    return result;
+	                });
 	            }
-	            const merged = mergeValues(parsedLeft.value, parsedRight.value);
-	            if (!merged.valid) {
-	                addIssueToContext(ctx, {
-	                    code: ZodIssueCode.invalid_intersection_types,
+	            else {
+	                if (status.value === "aborted")
+	                    return INVALID;
+	                const result = this._def.schema._parseSync({
+	                    data: processed,
+	                    path: ctx.path,
+	                    parent: ctx,
+	                });
+	                if (result.status === "aborted")
+	                    return INVALID;
+	                if (result.status === "dirty")
+	                    return DIRTY(result.value);
+	                if (status.value === "dirty")
+	                    return DIRTY(result.value);
+	                return result;
+	            }
+	        }
+	        if (effect.type === "refinement") {
+	            const executeRefinement = (acc) => {
+	                const result = effect.refinement(acc, checkCtx);
+	                if (ctx.common.async) {
+	                    return Promise.resolve(result);
+	                }
+	                if (result instanceof Promise) {
+	                    throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+	                }
+	                return acc;
+	            };
+	            if (ctx.common.async === false) {
+	                const inner = this._def.schema._parseSync({
+	                    data: ctx.data,
+	                    path: ctx.path,
+	                    parent: ctx,
+	                });
+	                if (inner.status === "aborted")
+	                    return INVALID;
+	                if (inner.status === "dirty")
+	                    status.dirty();
+	                // return value is ignored
+	                executeRefinement(inner.value);
+	                return { status: status.value, value: inner.value };
+	            }
+	            else {
+	                return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
+	                    if (inner.status === "aborted")
+	                        return INVALID;
+	                    if (inner.status === "dirty")
+	                        status.dirty();
+	                    return executeRefinement(inner.value).then(() => {
+	                        return { status: status.value, value: inner.value };
+	                    });
 	                });
-	                return INVALID;
-	            }
-	            if (isDirty(parsedLeft) || isDirty(parsedRight)) {
-	                status.dirty();
 	            }
-	            return { status: status.value, value: merged.data };
-	        };
-	        if (ctx.common.async) {
-	            return Promise.all([
-	                this._def.left._parseAsync({
-	                    data: ctx.data,
-	                    path: ctx.path,
-	                    parent: ctx,
-	                }),
-	                this._def.right._parseAsync({
+	        }
+	        if (effect.type === "transform") {
+	            if (ctx.common.async === false) {
+	                const base = this._def.schema._parseSync({
 	                    data: ctx.data,
 	                    path: ctx.path,
 	                    parent: ctx,
-	                }),
-	            ]).then(([left, right]) => handleParsed(left, right));
-	        }
-	        else {
-	            return handleParsed(this._def.left._parseSync({
-	                data: ctx.data,
-	                path: ctx.path,
-	                parent: ctx,
-	            }), this._def.right._parseSync({
-	                data: ctx.data,
-	                path: ctx.path,
-	                parent: ctx,
-	            }));
+	                });
+	                if (!isValid(base))
+	                    return INVALID;
+	                const result = effect.transform(base.value, checkCtx);
+	                if (result instanceof Promise) {
+	                    throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
+	                }
+	                return { status: status.value, value: result };
+	            }
+	            else {
+	                return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
+	                    if (!isValid(base))
+	                        return INVALID;
+	                    return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
+	                        status: status.value,
+	                        value: result,
+	                    }));
+	                });
+	            }
 	        }
+	        util.assertNever(effect);
 	    }
 	}
-	ZodIntersection.create = (left, right, params) => {
-	    return new ZodIntersection({
-	        left: left,
-	        right: right,
-	        typeName: ZodFirstPartyTypeKind.ZodIntersection,
+	ZodEffects.create = (schema, effect, params) => {
+	    return new ZodEffects({
+	        schema,
+	        typeName: ZodFirstPartyTypeKind.ZodEffects,
+	        effect,
 	        ...processCreateParams(params),
 	    });
 	};
-	// type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
-	class ZodTuple extends ZodType {
+	ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
+	    return new ZodEffects({
+	        schema,
+	        effect: { type: "preprocess", transform: preprocess },
+	        typeName: ZodFirstPartyTypeKind.ZodEffects,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodOptional extends ZodType {
 	    _parse(input) {
-	        const { status, ctx } = this._processInputParams(input);
-	        if (ctx.parsedType !== ZodParsedType.array) {
-	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.invalid_type,
-	                expected: ZodParsedType.array,
-	                received: ctx.parsedType,
-	            });
-	            return INVALID;
-	        }
-	        if (ctx.data.length < this._def.items.length) {
-	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.too_small,
-	                minimum: this._def.items.length,
-	                inclusive: true,
-	                exact: false,
-	                type: "array",
-	            });
-	            return INVALID;
-	        }
-	        const rest = this._def.rest;
-	        if (!rest && ctx.data.length > this._def.items.length) {
-	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.too_big,
-	                maximum: this._def.items.length,
-	                inclusive: true,
-	                exact: false,
-	                type: "array",
-	            });
-	            status.dirty();
-	        }
-	        const items = [...ctx.data]
-	            .map((item, itemIndex) => {
-	            const schema = this._def.items[itemIndex] || this._def.rest;
-	            if (!schema)
-	                return null;
-	            return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
-	        })
-	            .filter((x) => !!x); // filter nulls
-	        if (ctx.common.async) {
-	            return Promise.all(items).then((results) => {
-	                return ParseStatus.mergeArray(status, results);
-	            });
-	        }
-	        else {
-	            return ParseStatus.mergeArray(status, items);
+	        const parsedType = this._getType(input);
+	        if (parsedType === ZodParsedType.undefined) {
+	            return OK(undefined);
 	        }
+	        return this._def.innerType._parse(input);
 	    }
-	    get items() {
-	        return this._def.items;
-	    }
-	    rest(rest) {
-	        return new ZodTuple({
-	            ...this._def,
-	            rest,
-	        });
+	    unwrap() {
+	        return this._def.innerType;
 	    }
 	}
-	ZodTuple.create = (schemas, params) => {
-	    if (!Array.isArray(schemas)) {
-	        throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
-	    }
-	    return new ZodTuple({
-	        items: schemas,
-	        typeName: ZodFirstPartyTypeKind.ZodTuple,
-	        rest: null,
+	ZodOptional.create = (type, params) => {
+	    return new ZodOptional({
+	        innerType: type,
+	        typeName: ZodFirstPartyTypeKind.ZodOptional,
 	        ...processCreateParams(params),
 	    });
 	};
-	class ZodMap extends ZodType {
-	    get keySchema() {
-	        return this._def.keyType;
+	class ZodNullable extends ZodType {
+	    _parse(input) {
+	        const parsedType = this._getType(input);
+	        if (parsedType === ZodParsedType.null) {
+	            return OK(null);
+	        }
+	        return this._def.innerType._parse(input);
 	    }
-	    get valueSchema() {
-	        return this._def.valueType;
+	    unwrap() {
+	        return this._def.innerType;
 	    }
+	}
+	ZodNullable.create = (type, params) => {
+	    return new ZodNullable({
+	        innerType: type,
+	        typeName: ZodFirstPartyTypeKind.ZodNullable,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodDefault extends ZodType {
 	    _parse(input) {
-	        const { status, ctx } = this._processInputParams(input);
-	        if (ctx.parsedType !== ZodParsedType.map) {
-	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.invalid_type,
-	                expected: ZodParsedType.map,
-	                received: ctx.parsedType,
-	            });
-	            return INVALID;
+	        const { ctx } = this._processInputParams(input);
+	        let data = ctx.data;
+	        if (ctx.parsedType === ZodParsedType.undefined) {
+	            data = this._def.defaultValue();
 	        }
-	        const keyType = this._def.keyType;
-	        const valueType = this._def.valueType;
-	        const pairs = [...ctx.data.entries()].map(([key, value], index) => {
-	            return {
-	                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
-	                value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"])),
-	            };
+	        return this._def.innerType._parse({
+	            data,
+	            path: ctx.path,
+	            parent: ctx,
 	        });
-	        if (ctx.common.async) {
-	            const finalMap = new Map();
-	            return Promise.resolve().then(async () => {
-	                for (const pair of pairs) {
-	                    const key = await pair.key;
-	                    const value = await pair.value;
-	                    if (key.status === "aborted" || value.status === "aborted") {
-	                        return INVALID;
-	                    }
-	                    if (key.status === "dirty" || value.status === "dirty") {
-	                        status.dirty();
-	                    }
-	                    finalMap.set(key.value, value.value);
-	                }
-	                return { status: status.value, value: finalMap };
-	            });
-	        }
-	        else {
-	            const finalMap = new Map();
-	            for (const pair of pairs) {
-	                const key = pair.key;
-	                const value = pair.value;
-	                if (key.status === "aborted" || value.status === "aborted") {
-	                    return INVALID;
-	                }
-	                if (key.status === "dirty" || value.status === "dirty") {
-	                    status.dirty();
-	                }
-	                finalMap.set(key.value, value.value);
-	            }
-	            return { status: status.value, value: finalMap };
+	    }
+	    removeDefault() {
+	        return this._def.innerType;
+	    }
+	}
+	ZodDefault.create = (type, params) => {
+	    return new ZodDefault({
+	        innerType: type,
+	        typeName: ZodFirstPartyTypeKind.ZodDefault,
+	        defaultValue: typeof params.default === "function" ? params.default : () => params.default,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodCatch extends ZodType {
+	    _parse(input) {
+	        const { ctx } = this._processInputParams(input);
+	        // newCtx is used to not collect issues from inner types in ctx
+	        const newCtx = {
+	            ...ctx,
+	            common: {
+	                ...ctx.common,
+	                issues: [],
+	            },
+	        };
+	        const result = this._def.innerType._parse({
+	            data: newCtx.data,
+	            path: newCtx.path,
+	            parent: {
+	                ...newCtx,
+	            },
+	        });
+	        if (isAsync(result)) {
+	            return result.then((result) => {
+	                return {
+	                    status: "valid",
+	                    value: result.status === "valid"
+	                        ? result.value
+	                        : this._def.catchValue({
+	                            get error() {
+	                                return new ZodError(newCtx.common.issues);
+	                            },
+	                            input: newCtx.data,
+	                        }),
+	                };
+	            });
+	        }
+	        else {
+	            return {
+	                status: "valid",
+	                value: result.status === "valid"
+	                    ? result.value
+	                    : this._def.catchValue({
+	                        get error() {
+	                            return new ZodError(newCtx.common.issues);
+	                        },
+	                        input: newCtx.data,
+	                    }),
+	            };
 	        }
 	    }
+	    removeCatch() {
+	        return this._def.innerType;
+	    }
 	}
-	ZodMap.create = (keyType, valueType, params) => {
-	    return new ZodMap({
-	        valueType,
-	        keyType,
-	        typeName: ZodFirstPartyTypeKind.ZodMap,
+	ZodCatch.create = (type, params) => {
+	    return new ZodCatch({
+	        innerType: type,
+	        typeName: ZodFirstPartyTypeKind.ZodCatch,
+	        catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
 	        ...processCreateParams(params),
 	    });
 	};
-	class ZodSet extends ZodType {
+	class ZodNaN extends ZodType {
 	    _parse(input) {
-	        const { status, ctx } = this._processInputParams(input);
-	        if (ctx.parsedType !== ZodParsedType.set) {
+	        const parsedType = this._getType(input);
+	        if (parsedType !== ZodParsedType.nan) {
+	            const ctx = this._getOrReturnCtx(input);
 	            addIssueToContext(ctx, {
 	                code: ZodIssueCode.invalid_type,
-	                expected: ZodParsedType.set,
+	                expected: ZodParsedType.nan,
 	                received: ctx.parsedType,
 	            });
 	            return INVALID;
 	        }
-	        const def = this._def;
-	        if (def.minSize !== null) {
-	            if (ctx.data.size < def.minSize.value) {
-	                addIssueToContext(ctx, {
-	                    code: ZodIssueCode.too_small,
-	                    minimum: def.minSize.value,
-	                    type: "set",
-	                    inclusive: true,
-	                    exact: false,
-	                    message: def.minSize.message,
+	        return { status: "valid", value: input.data };
+	    }
+	}
+	ZodNaN.create = (params) => {
+	    return new ZodNaN({
+	        typeName: ZodFirstPartyTypeKind.ZodNaN,
+	        ...processCreateParams(params),
+	    });
+	};
+	class ZodBranded extends ZodType {
+	    _parse(input) {
+	        const { ctx } = this._processInputParams(input);
+	        const data = ctx.data;
+	        return this._def.type._parse({
+	            data,
+	            path: ctx.path,
+	            parent: ctx,
+	        });
+	    }
+	    unwrap() {
+	        return this._def.type;
+	    }
+	}
+	class ZodPipeline extends ZodType {
+	    _parse(input) {
+	        const { status, ctx } = this._processInputParams(input);
+	        if (ctx.common.async) {
+	            const handleAsync = async () => {
+	                const inResult = await this._def.in._parseAsync({
+	                    data: ctx.data,
+	                    path: ctx.path,
+	                    parent: ctx,
 	                });
+	                if (inResult.status === "aborted")
+	                    return INVALID;
+	                if (inResult.status === "dirty") {
+	                    status.dirty();
+	                    return DIRTY(inResult.value);
+	                }
+	                else {
+	                    return this._def.out._parseAsync({
+	                        data: inResult.value,
+	                        path: ctx.path,
+	                        parent: ctx,
+	                    });
+	                }
+	            };
+	            return handleAsync();
+	        }
+	        else {
+	            const inResult = this._def.in._parseSync({
+	                data: ctx.data,
+	                path: ctx.path,
+	                parent: ctx,
+	            });
+	            if (inResult.status === "aborted")
+	                return INVALID;
+	            if (inResult.status === "dirty") {
 	                status.dirty();
+	                return {
+	                    status: "dirty",
+	                    value: inResult.value,
+	                };
+	            }
+	            else {
+	                return this._def.out._parseSync({
+	                    data: inResult.value,
+	                    path: ctx.path,
+	                    parent: ctx,
+	                });
 	            }
 	        }
-	        if (def.maxSize !== null) {
-	            if (ctx.data.size > def.maxSize.value) {
-	                addIssueToContext(ctx, {
-	                    code: ZodIssueCode.too_big,
-	                    maximum: def.maxSize.value,
-	                    type: "set",
-	                    inclusive: true,
-	                    exact: false,
-	                    message: def.maxSize.message,
+	    }
+	    static create(a, b) {
+	        return new ZodPipeline({
+	            in: a,
+	            out: b,
+	            typeName: ZodFirstPartyTypeKind.ZodPipeline,
+	        });
+	    }
+	}
+	class ZodReadonly extends ZodType {
+	    _parse(input) {
+	        const result = this._def.innerType._parse(input);
+	        const freeze = (data) => {
+	            if (isValid(data)) {
+	                data.value = Object.freeze(data.value);
+	            }
+	            return data;
+	        };
+	        return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
+	    }
+	    unwrap() {
+	        return this._def.innerType;
+	    }
+	}
+	ZodReadonly.create = (type, params) => {
+	    return new ZodReadonly({
+	        innerType: type,
+	        typeName: ZodFirstPartyTypeKind.ZodReadonly,
+	        ...processCreateParams(params),
+	    });
+	};
+	var ZodFirstPartyTypeKind;
+	(function (ZodFirstPartyTypeKind) {
+	    ZodFirstPartyTypeKind["ZodString"] = "ZodString";
+	    ZodFirstPartyTypeKind["ZodNumber"] = "ZodNumber";
+	    ZodFirstPartyTypeKind["ZodNaN"] = "ZodNaN";
+	    ZodFirstPartyTypeKind["ZodBigInt"] = "ZodBigInt";
+	    ZodFirstPartyTypeKind["ZodBoolean"] = "ZodBoolean";
+	    ZodFirstPartyTypeKind["ZodDate"] = "ZodDate";
+	    ZodFirstPartyTypeKind["ZodSymbol"] = "ZodSymbol";
+	    ZodFirstPartyTypeKind["ZodUndefined"] = "ZodUndefined";
+	    ZodFirstPartyTypeKind["ZodNull"] = "ZodNull";
+	    ZodFirstPartyTypeKind["ZodAny"] = "ZodAny";
+	    ZodFirstPartyTypeKind["ZodUnknown"] = "ZodUnknown";
+	    ZodFirstPartyTypeKind["ZodNever"] = "ZodNever";
+	    ZodFirstPartyTypeKind["ZodVoid"] = "ZodVoid";
+	    ZodFirstPartyTypeKind["ZodArray"] = "ZodArray";
+	    ZodFirstPartyTypeKind["ZodObject"] = "ZodObject";
+	    ZodFirstPartyTypeKind["ZodUnion"] = "ZodUnion";
+	    ZodFirstPartyTypeKind["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
+	    ZodFirstPartyTypeKind["ZodIntersection"] = "ZodIntersection";
+	    ZodFirstPartyTypeKind["ZodTuple"] = "ZodTuple";
+	    ZodFirstPartyTypeKind["ZodRecord"] = "ZodRecord";
+	    ZodFirstPartyTypeKind["ZodMap"] = "ZodMap";
+	    ZodFirstPartyTypeKind["ZodSet"] = "ZodSet";
+	    ZodFirstPartyTypeKind["ZodFunction"] = "ZodFunction";
+	    ZodFirstPartyTypeKind["ZodLazy"] = "ZodLazy";
+	    ZodFirstPartyTypeKind["ZodLiteral"] = "ZodLiteral";
+	    ZodFirstPartyTypeKind["ZodEnum"] = "ZodEnum";
+	    ZodFirstPartyTypeKind["ZodEffects"] = "ZodEffects";
+	    ZodFirstPartyTypeKind["ZodNativeEnum"] = "ZodNativeEnum";
+	    ZodFirstPartyTypeKind["ZodOptional"] = "ZodOptional";
+	    ZodFirstPartyTypeKind["ZodNullable"] = "ZodNullable";
+	    ZodFirstPartyTypeKind["ZodDefault"] = "ZodDefault";
+	    ZodFirstPartyTypeKind["ZodCatch"] = "ZodCatch";
+	    ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise";
+	    ZodFirstPartyTypeKind["ZodBranded"] = "ZodBranded";
+	    ZodFirstPartyTypeKind["ZodPipeline"] = "ZodPipeline";
+	    ZodFirstPartyTypeKind["ZodReadonly"] = "ZodReadonly";
+	})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+	const stringType = ZodString.create;
+	const booleanType = ZodBoolean.create;
+	const anyType = ZodAny.create;
+	ZodUnknown.create;
+	ZodNever.create;
+	const arrayType = ZodArray.create;
+	const objectType = ZodObject.create;
+	ZodUnion.create;
+	ZodIntersection.create;
+	ZodTuple.create;
+	const functionType = ZodFunction.create;
+	const lazyType = ZodLazy.create;
+	ZodEnum.create;
+	const nativeEnumType = ZodNativeEnum.create;
+	ZodPromise.create;
+	ZodOptional.create;
+	ZodNullable.create;
+
+	const POPUP_ELEMENT_ID = '__integration-app-popup';
+	const CONTAINER_ELEMENT_ID = '__integration-app-container';
+	const CONTAINER_ELEMENT_CLASS = '__integration-app-container';
+	const CONTAINER_ELEMENT_CLASS__LOADER = '__integration-app-container__loader';
+	const BODY_CLASS = '__integration-app-open';
+	const STYLES_ELEMENT_ID = '__integration-app-embed-styles';
+	objectType({
+	    onClose: functionType().optional(),
+	    showPoweredBy: booleanType().optional(),
+	});
+	let IFRAME_START_SHOW_LOADER_TIME = 0;
+	let IFRAME_SHOW_LOADER_TIMEOUT_ID;
+	const IFRAME_SHOW_LOADER_MINIMAL_TIME = 500;
+	const IFRAME_LAYOUT_SHIFT_TIME = 300;
+	function showIframeLoader() {
+	    const container = getContainer();
+	    container === null || container === void 0 ? void 0 : container.classList.add(CONTAINER_ELEMENT_CLASS__LOADER);
+	    IFRAME_START_SHOW_LOADER_TIME = Date.now();
+	}
+	function hideIframeLoader(waitLayoutShift = IFRAME_LAYOUT_SHIFT_TIME) {
+	    if (IFRAME_SHOW_LOADER_TIMEOUT_ID) {
+	        clearTimeout(IFRAME_SHOW_LOADER_TIMEOUT_ID);
+	    }
+	    const delta = Date.now() - IFRAME_START_SHOW_LOADER_TIME;
+	    if (delta >= IFRAME_SHOW_LOADER_MINIMAL_TIME) {
+	        setTimeout(() => {
+	            const container = getContainer();
+	            container === null || container === void 0 ? void 0 : container.classList.remove(CONTAINER_ELEMENT_CLASS__LOADER);
+	            IFRAME_START_SHOW_LOADER_TIME = 0;
+	        }, waitLayoutShift);
+	        return;
+	    }
+	    else {
+	        const waitLayoutShift = delta >= IFRAME_LAYOUT_SHIFT_TIME ? 0 : IFRAME_LAYOUT_SHIFT_TIME - delta;
+	        const timeoutTime = IFRAME_SHOW_LOADER_MINIMAL_TIME - delta;
+	        IFRAME_SHOW_LOADER_TIMEOUT_ID = setTimeout(() => {
+	            hideIframeLoader(waitLayoutShift);
+	        }, timeoutTime);
+	        return;
+	    }
+	}
+	async function openIframe(uri, callbacks = {}, { mountTargetSelector } = {}) {
+	    close();
+	    init(mountTargetSelector);
+	    return new Promise((resolve) => {
+	        function complete(callback) {
+	            close(callback);
+	            resolve();
+	        }
+	        function doOpen() {
+	            const iframe = document.createElement('iframe');
+	            iframe.src = uri;
+	            iframe.id = POPUP_ELEMENT_ID;
+	            iframe.onload = () => {
+	                hideIframeLoader();
+	            };
+	            if (!!getContainer()) {
+	                document.body.classList.add(BODY_CLASS);
+	                showIframeLoader();
+	                appendToContainer(iframe);
+	                handleIframeUnmount(iframe);
+	                connectToChild({
+	                    iframe,
+	                    methods: {
+	                        ...callbacks,
+	                        handshake: (...args) => {
+	                            var _a;
+	                            hideIframeLoader();
+	                            (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.handshake) === null || _a === void 0 ? void 0 : _a.call(callbacks, ...args);
+	                        },
+	                        close: () => complete(callbacks.onClose),
+	                    },
 	                });
-	                status.dirty();
 	            }
-	        }
-	        const valueType = this._def.valueType;
-	        function finalizeSet(elements) {
-	            const parsedSet = new Set();
-	            for (const element of elements) {
-	                if (element.status === "aborted")
-	                    return INVALID;
-	                if (element.status === "dirty")
-	                    status.dirty();
-	                parsedSet.add(element.value);
+	            else {
+	                throw Error('Membrane container element not found. Was it manually removed?');
 	            }
-	            return { status: status.value, value: parsedSet };
 	        }
-	        const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
-	        if (ctx.common.async) {
-	            return Promise.all(elements).then((elements) => finalizeSet(elements));
+	        if (document.readyState === 'complete' || document.readyState === 'interactive') {
+	            doOpen();
 	        }
 	        else {
-	            return finalizeSet(elements);
-	        }
-	    }
-	    min(minSize, message) {
-	        return new ZodSet({
-	            ...this._def,
-	            minSize: { value: minSize, message: errorUtil.toString(message) },
-	        });
-	    }
-	    max(maxSize, message) {
-	        return new ZodSet({
-	            ...this._def,
-	            maxSize: { value: maxSize, message: errorUtil.toString(message) },
-	        });
-	    }
-	    size(size, message) {
-	        return this.min(size, message).max(size, message);
-	    }
-	    nonempty(message) {
-	        return this.min(1, message);
-	    }
-	}
-	ZodSet.create = (valueType, params) => {
-	    return new ZodSet({
-	        valueType,
-	        minSize: null,
-	        maxSize: null,
-	        typeName: ZodFirstPartyTypeKind.ZodSet,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodLazy extends ZodType {
-	    get schema() {
-	        return this._def.getter();
-	    }
-	    _parse(input) {
-	        const { ctx } = this._processInputParams(input);
-	        const lazySchema = this._def.getter();
-	        return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
-	    }
-	}
-	ZodLazy.create = (getter, params) => {
-	    return new ZodLazy({
-	        getter: getter,
-	        typeName: ZodFirstPartyTypeKind.ZodLazy,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodLiteral extends ZodType {
-	    _parse(input) {
-	        if (input.data !== this._def.value) {
-	            const ctx = this._getOrReturnCtx(input);
-	            addIssueToContext(ctx, {
-	                received: ctx.data,
-	                code: ZodIssueCode.invalid_literal,
-	                expected: this._def.value,
+	            document.addEventListener('DOMContentLoaded', () => {
+	                doOpen();
 	            });
-	            return INVALID;
 	        }
-	        return { status: "valid", value: input.data };
-	    }
-	    get value() {
-	        return this._def.value;
-	    }
-	}
-	ZodLiteral.create = (value, params) => {
-	    return new ZodLiteral({
-	        value: value,
-	        typeName: ZodFirstPartyTypeKind.ZodLiteral,
-	        ...processCreateParams(params),
-	    });
-	};
-	function createZodEnum(values, params) {
-	    return new ZodEnum({
-	        values,
-	        typeName: ZodFirstPartyTypeKind.ZodEnum,
-	        ...processCreateParams(params),
 	    });
 	}
-	class ZodEnum extends ZodType {
-	    _parse(input) {
-	        if (typeof input.data !== "string") {
-	            const ctx = this._getOrReturnCtx(input);
-	            const expectedValues = this._def.values;
-	            addIssueToContext(ctx, {
-	                expected: util.joinValues(expectedValues),
-	                received: ctx.parsedType,
-	                code: ZodIssueCode.invalid_type,
-	            });
-	            return INVALID;
-	        }
-	        if (!this._cache) {
-	            this._cache = new Set(this._def.values);
-	        }
-	        if (!this._cache.has(input.data)) {
-	            const ctx = this._getOrReturnCtx(input);
-	            const expectedValues = this._def.values;
-	            addIssueToContext(ctx, {
-	                received: ctx.data,
-	                code: ZodIssueCode.invalid_enum_value,
-	                options: expectedValues,
-	            });
-	            return INVALID;
-	        }
-	        return OK(input.data);
-	    }
-	    get options() {
-	        return this._def.values;
-	    }
-	    get enum() {
-	        const enumValues = {};
-	        for (const val of this._def.values) {
-	            enumValues[val] = val;
+	function close(callback) {
+	    document.body.classList.remove(BODY_CLASS);
+	    if (!!getContainer()) {
+	        deleteContainer();
+	        if (callback) {
+	            callback();
 	        }
-	        return enumValues;
 	    }
-	    get Values() {
-	        const enumValues = {};
-	        for (const val of this._def.values) {
-	            enumValues[val] = val;
-	        }
-	        return enumValues;
+	}
+	function init(mountTargetSelector) {
+	    var _a;
+	    injectStyles(mountTargetSelector);
+	    if (!!getContainer()) {
+	        return;
 	    }
-	    get Enum() {
-	        const enumValues = {};
-	        for (const val of this._def.values) {
-	            enumValues[val] = val;
-	        }
-	        return enumValues;
+	    const container = createContainer();
+	    if (mountTargetSelector && document.querySelector(mountTargetSelector)) {
+	        (_a = document.querySelector(mountTargetSelector)) === null || _a === void 0 ? void 0 : _a.appendChild(container);
 	    }
-	    extract(values, newDef = this._def) {
-	        return ZodEnum.create(values, {
-	            ...this._def,
-	            ...newDef,
-	        });
+	    else {
+	        document.body.appendChild(container);
 	    }
-	    exclude(values, newDef = this._def) {
-	        return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
-	            ...this._def,
-	            ...newDef,
-	        });
+	}
+	function injectStyles(mountTargetSelector) {
+	    const hasCustomMountTarget = Boolean(mountTargetSelector && document.querySelector(mountTargetSelector));
+	    const styles = [
+	        `.${CONTAINER_ELEMENT_CLASS}:empty {
+      display: none;
+    }`,
+	        hasCustomMountTarget
+	            ? `.${CONTAINER_ELEMENT_CLASS} {
+        inset: 0;
+        background: rgba(0, 0, 0, 0);
+        transition: background 0.2s ease-out;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        width: 100%;
+        height: 100%;
+      }`
+	            : `.${CONTAINER_ELEMENT_CLASS} {
+        position: fixed;
+        inset: 0;
+        z-index: 2147483647;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        pointer-events: auto;
+        background: rgba(0, 0, 0, 0);
+        transition: background 0.2s ease-out;
+      }`,
+	        `.${CONTAINER_ELEMENT_CLASS}.${CONTAINER_ELEMENT_CLASS__LOADER} {
+      background: rgba(0, 0, 0, 0.8);
+    }`,
+	        `.${CONTAINER_ELEMENT_CLASS}.${CONTAINER_ELEMENT_CLASS__LOADER}::before {
+      ${hasCustomMountTarget ? 'position: absolute;' : ''}
+      content: "";
+      width: 5rem;
+      height: 4rem;
+      background-image: url('data:image/svg+xml,%3Csvg viewBox="0 0 32 22" fill="%23000" xmlns="http://www.w3.org/2000/svg" %3E%3Cdefs%3E%3Cmask id="a"%3E%3Crect width="100%25" height="100%25" fill="%23fff" /%3E%3Cpath d="M11.8 13.12a3 3 0 0 1 0-4.24l7.08-7.07a3 3 0 0 1 4.24 0l7.07 7.07a3 3 0 0 1 0 4.24l-7.07 7.07a3 3 0 0 1-4.24 0l-7.07-7.07Z"%3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 21 11" to="-360 21 11" /%3E%3C/path%3E%3C/mask%3E%3Cmask id="b"%3E%3Crect width="100%25" height="100%25" fill="%23fff"/%3E%3Cpath fill-rule="evenodd" clip-rule="evenodd" d="M1.8 8.88a3 3 0 0 0 0 4.24l7.08 7.07a3 3 0 0 0 4.24 0l7.07-7.07a3 3 0 0 0 0-4.24L13.12 1.8a3 3 0 0 0-4.24 0L1.8 8.88Zm.71.7a2 2 0 0 0 0 2.83L9.6 19.5a2 2 0 0 0 2.82 0l7.08-7.08a2 2 0 0 0 0-2.82l-7.1-7.1a2 2 0 0 0-2.82 0L2.5 9.6Z" %3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 11 11" to="720 11 11" /%3E%3C/path%3E%3C/mask%3E%3C/defs%3E%3Cg mask="url(%23a)"%3E%3Cpath fill-rule="evenodd" clip-rule="evenodd" d="M1.8 8.88a3 3 0 0 0 0 4.24l7.08 7.07a3 3 0 0 0 4.24 0l7.07-7.07a3 3 0 0 0 0-4.24L13.12 1.8a3 3 0 0 0-4.24 0L1.8 8.88Zm.71.7a2 2 0 0 0 0 2.83L9.6 19.5a2 2 0 0 0 2.82 0l7.08-7.08a2 2 0 0 0 0-2.82l-7.1-7.1a2 2 0 0 0-2.82 0L2.5 9.6Z"%0A%3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 11 11" to="720 11 11" /%3E%3C/path%3E%3C/g%3E%3Cg mask="url(%23b)"%3E%3Cpath d="M11.8 13.12a3 3 0 0 1 0-4.24l7.08-7.07a3 3 0 0 1 4.24 0l7.07 7.07a3 3 0 0 1 0 4.24l-7.07 7.07a3 3 0 0 1-4.24 0l-7.07-7.07Z"%3E%3CanimateTransform attributeName="transform" attributeType="XML" type="rotate" repeatCount="indefinite" calcMode="spline" keyTimes="0;1" dur="5s" keySplines="0 0 0.1 1" from="0 21 11" to="-360 21 11" /%3E%3C/path%3E%3C/g%3E%3C/svg%3E');
+      background-size: contain;
+      background-repeat: no-repeat;
+      background-position: center;
+      filter: invert(1);
+    }`,
+	        `.${CONTAINER_ELEMENT_CLASS} iframe {
+      ${hasCustomMountTarget ? '' : 'position: absolute;'}
+      width: 100%;
+      height: 100%;
+      border-width: 0;
+
+      /* fix transparent bg, because iframe document has light scheme */
+      color-scheme: light;
+    }`,
+	        `.${CONTAINER_ELEMENT_CLASS}.${CONTAINER_ELEMENT_CLASS__LOADER} iframe {
+      visibility: hidden;
+    }`,
+	        !hasCustomMountTarget
+	            ? `body.${BODY_CLASS} {
+          overflow: hidden;
+        }`
+	            : '',
+	    ];
+	    let styleElement = document.getElementById(STYLES_ELEMENT_ID);
+	    if (!styleElement) {
+	        styleElement = document.createElement('style');
+	        styleElement.id = STYLES_ELEMENT_ID;
+	        styleElement.type = 'text/css';
+	        document.head.appendChild(styleElement);
 	    }
+	    styleElement.textContent = styles.join('\n');
 	}
-	ZodEnum.create = createZodEnum;
-	class ZodNativeEnum extends ZodType {
-	    _parse(input) {
-	        const nativeEnumValues = util.getValidEnumValues(this._def.values);
-	        const ctx = this._getOrReturnCtx(input);
-	        if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
-	            const expectedValues = util.objectValues(nativeEnumValues);
-	            addIssueToContext(ctx, {
-	                expected: util.joinValues(expectedValues),
-	                received: ctx.parsedType,
-	                code: ZodIssueCode.invalid_type,
-	            });
-	            return INVALID;
-	        }
-	        if (!this._cache) {
-	            this._cache = new Set(util.getValidEnumValues(this._def.values));
-	        }
-	        if (!this._cache.has(input.data)) {
-	            const expectedValues = util.objectValues(nativeEnumValues);
-	            addIssueToContext(ctx, {
-	                received: ctx.data,
-	                code: ZodIssueCode.invalid_enum_value,
-	                options: expectedValues,
-	            });
-	            return INVALID;
-	        }
-	        return OK(input.data);
+	function removeInjectedStyles() {
+	    const stylesElement = document.getElementById(STYLES_ELEMENT_ID);
+	    if (stylesElement) {
+	        stylesElement.remove();
 	    }
-	    get enum() {
-	        return this._def.values;
+	}
+	function createContainer() {
+	    const container = document.createElement('div');
+	    container.id = CONTAINER_ELEMENT_ID;
+	    container.classList.add(CONTAINER_ELEMENT_CLASS);
+	    return container;
+	}
+	function getContainer() {
+	    return document.getElementById(CONTAINER_ELEMENT_ID);
+	}
+	function appendToContainer(el) {
+	    const container = getContainer();
+	    container === null || container === void 0 ? void 0 : container.appendChild(el);
+	}
+	function deleteContainer() {
+	    const container = getContainer();
+	    if (container) {
+	        container.remove();
 	    }
+	    removeInjectedStyles();
 	}
-	ZodNativeEnum.create = (values, params) => {
-	    return new ZodNativeEnum({
-	        values: values,
-	        typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
-	        ...processCreateParams(params),
+	function handleIframeUnmount(iframe) {
+	    const observer = new MutationObserver((mutationsList) => {
+	        for (const mutation of mutationsList) {
+	            for (const removedNode of mutation.removedNodes) {
+	                if (removedNode instanceof HTMLElement && removedNode.id === POPUP_ELEMENT_ID) {
+	                    observer.disconnect();
+	                    deleteContainer();
+	                    return;
+	                }
+	            }
+	        }
 	    });
-	};
-	class ZodPromise extends ZodType {
-	    unwrap() {
-	        return this._def.type;
+	    const parent = iframe.parentNode;
+	    if (parent) {
+	        observer.observe(parent, {
+	            childList: true,
+	        });
 	    }
-	    _parse(input) {
-	        const { ctx } = this._processInputParams(input);
-	        if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
-	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.invalid_type,
-	                expected: ZodParsedType.promise,
-	                received: ctx.parsedType,
-	            });
-	            return INVALID;
-	        }
-	        const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
-	        return OK(promisified.then((data) => {
-	            return this._def.type.parseAsync(data, {
-	                path: ctx.path,
-	                errorMap: ctx.common.contextualErrorMap,
-	            });
-	        }));
+	    else {
+	        console.warn(`iframe with ID "${POPUP_ELEMENT_ID}" has no parent node`);
 	    }
 	}
-	ZodPromise.create = (schema, params) => {
-	    return new ZodPromise({
-	        type: schema,
-	        typeName: ZodFirstPartyTypeKind.ZodPromise,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodEffects extends ZodType {
-	    innerType() {
-	        return this._def.schema;
+
+	class ConnectionLevelElementAccessor {
+	    constructor(client, connectionSelector, selector, elementKey, query) {
+	        this.client = client;
+	        this.connectionSelector = connectionSelector;
+	        this.selector = selector;
+	        this.elementKey = elementKey;
+	        this.query = query;
+	        this.endpoint = `/connections/${this.connectionSelector}/${elementKey}/${selector}`;
 	    }
-	    sourceType() {
-	        return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects
-	            ? this._def.schema.sourceType()
-	            : this._def.schema;
+	    uri(path = '', query = {}) {
+	        return this.endpoint + path + '?' + qs.stringify({ ...this.query, ...query });
 	    }
-	    _parse(input) {
-	        const { status, ctx } = this._processInputParams(input);
-	        const effect = this._def.effect || null;
-	        const checkCtx = {
-	            addIssue: (arg) => {
-	                addIssueToContext(ctx, arg);
-	                if (arg.fatal) {
-	                    status.abort();
-	                }
-	                else {
-	                    status.dirty();
-	                }
-	            },
-	            get path() {
-	                return ctx.path;
-	            },
-	        };
-	        checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
-	        if (effect.type === "preprocess") {
-	            const processed = effect.transform(ctx.data, checkCtx);
-	            if (ctx.common.async) {
-	                return Promise.resolve(processed).then(async (processed) => {
-	                    if (status.value === "aborted")
-	                        return INVALID;
-	                    const result = await this._def.schema._parseAsync({
-	                        data: processed,
-	                        path: ctx.path,
-	                        parent: ctx,
-	                    });
-	                    if (result.status === "aborted")
-	                        return INVALID;
-	                    if (result.status === "dirty")
-	                        return DIRTY(result.value);
-	                    if (status.value === "dirty")
-	                        return DIRTY(result.value);
-	                    return result;
-	                });
-	            }
-	            else {
-	                if (status.value === "aborted")
-	                    return INVALID;
-	                const result = this._def.schema._parseSync({
-	                    data: processed,
-	                    path: ctx.path,
-	                    parent: ctx,
-	                });
-	                if (result.status === "aborted")
-	                    return INVALID;
-	                if (result.status === "dirty")
-	                    return DIRTY(result.value);
-	                if (status.value === "dirty")
-	                    return DIRTY(result.value);
-	                return result;
-	            }
-	        }
-	        if (effect.type === "refinement") {
-	            const executeRefinement = (acc) => {
-	                const result = effect.refinement(acc, checkCtx);
-	                if (ctx.common.async) {
-	                    return Promise.resolve(result);
-	                }
-	                if (result instanceof Promise) {
-	                    throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
-	                }
-	                return acc;
-	            };
-	            if (ctx.common.async === false) {
-	                const inner = this._def.schema._parseSync({
-	                    data: ctx.data,
-	                    path: ctx.path,
-	                    parent: ctx,
-	                });
-	                if (inner.status === "aborted")
-	                    return INVALID;
-	                if (inner.status === "dirty")
-	                    status.dirty();
-	                // return value is ignored
-	                executeRefinement(inner.value);
-	                return { status: status.value, value: inner.value };
-	            }
-	            else {
-	                return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
-	                    if (inner.status === "aborted")
-	                        return INVALID;
-	                    if (inner.status === "dirty")
-	                        status.dirty();
-	                    return executeRefinement(inner.value).then(() => {
-	                        return { status: status.value, value: inner.value };
-	                    });
-	                });
-	            }
-	        }
-	        if (effect.type === "transform") {
-	            if (ctx.common.async === false) {
-	                const base = this._def.schema._parseSync({
-	                    data: ctx.data,
-	                    path: ctx.path,
-	                    parent: ctx,
-	                });
-	                if (!isValid(base))
-	                    return INVALID;
-	                const result = effect.transform(base.value, checkCtx);
-	                if (result instanceof Promise) {
-	                    throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
-	                }
-	                return { status: status.value, value: result };
-	            }
-	            else {
-	                return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
-	                    if (!isValid(base))
-	                        return INVALID;
-	                    return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
-	                        status: status.value,
-	                        value: result,
-	                    }));
-	                });
-	            }
-	        }
-	        util.assertNever(effect);
+	    getUniqueIdentifier() {
+	        return this.endpoint;
+	    }
+	    async get(query = {}) {
+	        return this.client.get(this.uri('', query));
+	    }
+	    async create() {
+	        return this.client.put(this.uri());
+	    }
+	    async patch(data) {
+	        return this.client.patch(this.uri(), data);
+	    }
+	    async put(data) {
+	        return this.client.put(this.uri(), data);
+	    }
+	    async archive() {
+	        return this.client.delete(this.uri());
+	    }
+	    async reset() {
+	        return this.client.post(this.uri('/reset'));
+	    }
+	    async setup() {
+	        return this.client.post(this.uri('/setup'));
 	    }
 	}
-	ZodEffects.create = (schema, effect, params) => {
-	    return new ZodEffects({
-	        schema,
-	        typeName: ZodFirstPartyTypeKind.ZodEffects,
-	        effect,
-	        ...processCreateParams(params),
-	    });
-	};
-	ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
-	    return new ZodEffects({
-	        schema,
-	        effect: { type: "preprocess", transform: preprocess },
-	        typeName: ZodFirstPartyTypeKind.ZodEffects,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodOptional extends ZodType {
-	    _parse(input) {
-	        const parsedType = this._getType(input);
-	        if (parsedType === ZodParsedType.undefined) {
-	            return OK(undefined);
-	        }
-	        return this._def.innerType._parse(input);
+	class ConnectionLevelElementsListAccessor {
+	    constructor(client, connectionSelector, elementKey) {
+	        this.client = client;
+	        this.connectionSelector = connectionSelector;
+	        this.elementKey = elementKey;
 	    }
-	    unwrap() {
-	        return this._def.innerType;
+	    async list(query) {
+	        const endpoint = `/connections/${this.connectionSelector}/${this.elementKey}?${qs.stringify(query !== null && query !== void 0 ? query : {})}`;
+	        return this.client.get(endpoint);
 	    }
 	}
-	ZodOptional.create = (type, params) => {
-	    return new ZodOptional({
-	        innerType: type,
-	        typeName: ZodFirstPartyTypeKind.ZodOptional,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodNullable extends ZodType {
-	    _parse(input) {
-	        const parsedType = this._getType(input);
-	        if (parsedType === ZodParsedType.null) {
-	            return OK(null);
-	        }
-	        return this._def.innerType._parse(input);
+
+	class ActionInstancesAccessor extends ElementInstanceListAccessor {
+	    constructor(client) {
+	        super(client, 'action-instances');
 	    }
-	    unwrap() {
-	        return this._def.innerType;
+	}
+	class ActionInstanceAccessor extends ElementInstanceAccessor {
+	    constructor(client, selector) {
+	        super({
+	            client,
+	            instancePath: 'action-instance',
+	            selector,
+	        });
+	        this.client = client;
+	    }
+	    async setup() {
+	        await this.client.post(this.getPath('setup'));
+	    }
+	    async reset() {
+	        await this.client.post(this.getPath('reset'));
+	    }
+	    async run(input) {
+	        return this.client.post(this.getPath('run'), input);
+	    }
+	    async open({ onClose = () => { } } = {}) {
+	        const id = await this.getId();
+	        const uri = await this.client.getEmbedUri(`action-instances/${id}/configuration`);
+	        return openIframe(uri, { onClose });
 	    }
 	}
-	ZodNullable.create = (type, params) => {
-	    return new ZodNullable({
-	        innerType: type,
-	        typeName: ZodFirstPartyTypeKind.ZodNullable,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodDefault extends ZodType {
-	    _parse(input) {
-	        const { ctx } = this._processInputParams(input);
-	        let data = ctx.data;
-	        if (ctx.parsedType === ZodParsedType.undefined) {
-	            data = this._def.defaultValue();
-	        }
-	        return this._def.innerType._parse({
-	            data,
-	            path: ctx.path,
-	            parent: ctx,
+	class ConnectionLevelActionAccessor extends ConnectionLevelElementAccessor {
+	    constructor(client, connectionSelector, actionSelector, query) {
+	        super(client, connectionSelector, actionSelector, 'actions', query);
+	        this.client = client;
+	        this.connectionSelector = connectionSelector;
+	        this.actionSelector = actionSelector;
+	        this.query = query;
+	    }
+	    async run(input) {
+	        return this.client.post(this.uri('/run'), input);
+	    }
+	}
+	class ConnectionLevelActionsAccessor extends ConnectionLevelElementsListAccessor {
+	    constructor(client, connectionSelector) {
+	        super(client, connectionSelector, 'actions');
+	        this.client = client;
+	        this.connectionSelector = connectionSelector;
+	    }
+	}
+
+	class DataSourcesAccessor extends ElementListAccessor {
+	    constructor(client) {
+	        super(client, 'data-sources');
+	    }
+	}
+	class DataSourceAccessor extends ElementAccessor {
+	    constructor(client, selector) {
+	        super({
+	            client,
+	            selector,
+	            path: 'data-source',
 	        });
 	    }
-	    removeDefault() {
-	        return this._def.innerType;
+	    async apply(integrationKeys) {
+	        return await this.options.client.post(this.getPath('apply'), {
+	            integrationKeys,
+	        });
+	    }
+	    async setup() {
+	        await this.options.client.post(this.getPath('setup'));
+	    }
+	    async reset() {
+	        return await this.options.client.post(this.getPath('reset'));
 	    }
 	}
-	ZodDefault.create = (type, params) => {
-	    return new ZodDefault({
-	        innerType: type,
-	        typeName: ZodFirstPartyTypeKind.ZodDefault,
-	        defaultValue: typeof params.default === "function" ? params.default : () => params.default,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodCatch extends ZodType {
-	    _parse(input) {
-	        const { ctx } = this._processInputParams(input);
-	        // newCtx is used to not collect issues from inner types in ctx
-	        const newCtx = {
-	            ...ctx,
-	            common: {
-	                ...ctx.common,
-	                issues: [],
-	            },
-	        };
-	        const result = this._def.innerType._parse({
-	            data: newCtx.data,
-	            path: newCtx.path,
-	            parent: {
-	                ...newCtx,
-	            },
+	class DataSourceInstancesAccessor extends ElementInstanceListAccessor {
+	    constructor(client) {
+	        super(client, 'data-source-instances');
+	    }
+	}
+	class DataSourceInstanceAccessor extends ElementInstanceAccessor {
+	    constructor(client, selector) {
+	        super({
+	            client,
+	            instancePath: 'data-source-instance',
+	            selector,
 	        });
-	        if (isAsync(result)) {
-	            return result.then((result) => {
-	                return {
-	                    status: "valid",
-	                    value: result.status === "valid"
-	                        ? result.value
-	                        : this._def.catchValue({
-	                            get error() {
-	                                return new ZodError(newCtx.common.issues);
-	                            },
-	                            input: newCtx.data,
-	                        }),
-	                };
-	            });
-	        }
-	        else {
-	            return {
-	                status: "valid",
-	                value: result.status === "valid"
-	                    ? result.value
-	                    : this._def.catchValue({
-	                        get error() {
-	                            return new ZodError(newCtx.common.issues);
-	                        },
-	                        input: newCtx.data,
-	                    }),
-	            };
-	        }
+	        this.client = client;
+	    }
+	    async setup() {
+	        await this.client.post(this.getPath('setup'));
+	    }
+	    async reset() {
+	        await this.client.post(this.getPath('reset'));
+	    }
+	    async openConfiguration({ onClose = () => { } } = {}) {
+	        const id = await this.getId();
+	        const uri = await this.client.getEmbedUri(`data-source-instances/${id}/configuration`);
+	        return openIframe(uri, {
+	            onClose,
+	        });
+	    }
+	    async unifiedFieldsToNative(unifiedFields) {
+	        return this.client.post(this.getPath('unified-fields-to-native'), unifiedFields);
+	    }
+	    async getCollection() {
+	        return this.client.get(this.getPath('collection'));
+	    }
+	    async listRecords(request = {}) {
+	        return this.client.post(this.getPath('collection/list'), request);
+	    }
+	    async matchRecord(request) {
+	        return this.client.post(this.getPath('collection/match'), request);
+	    }
+	    async searchRecords(request) {
+	        return this.client.post(this.getPath('collection/search'), request);
+	    }
+	    async findRecordById(request) {
+	        const data = typeof request === 'string' ? { id: request } : request;
+	        return this.client.post(this.getPath('collection/find-by-id'), data);
+	    }
+	    async createRecord(request) {
+	        return this.client.post(this.getPath('collection/create'), request);
 	    }
-	    removeCatch() {
-	        return this._def.innerType;
+	    async updateRecord(request) {
+	        return this.client.post(this.getPath(`collection/update`), request);
+	    }
+	    async deleteRecord(request) {
+	        const data = typeof request === 'string' ? { id: request } : request;
+	        return this.client.post(this.getPath(`collection/delete`), data);
+	    }
+	    async findRecords(request = {}) {
+	        return this.client.post(this.getPath('collection/find'), request);
 	    }
 	}
-	ZodCatch.create = (type, params) => {
-	    return new ZodCatch({
-	        innerType: type,
-	        typeName: ZodFirstPartyTypeKind.ZodCatch,
-	        catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodNaN extends ZodType {
-	    _parse(input) {
-	        const parsedType = this._getType(input);
-	        if (parsedType !== ZodParsedType.nan) {
-	            const ctx = this._getOrReturnCtx(input);
-	            addIssueToContext(ctx, {
-	                code: ZodIssueCode.invalid_type,
-	                expected: ZodParsedType.nan,
-	                received: ctx.parsedType,
-	            });
-	            return INVALID;
-	        }
-	        return { status: "valid", value: input.data };
+	class IntegrationLevelDataSourceAccessor extends IntegrationLevelElementAccessor {
+	    constructor(client, integrationSelector, dataSourceSelector) {
+	        super(client, integrationSelector, dataSourceSelector, 'data-sources');
+	        this.client = client;
+	        this.integrationSelector = integrationSelector;
+	        this.dataSourceSelector = dataSourceSelector;
 	    }
 	}
-	ZodNaN.create = (params) => {
-	    return new ZodNaN({
-	        typeName: ZodFirstPartyTypeKind.ZodNaN,
-	        ...processCreateParams(params),
-	    });
-	};
-	class ZodBranded extends ZodType {
-	    _parse(input) {
-	        const { ctx } = this._processInputParams(input);
-	        const data = ctx.data;
-	        return this._def.type._parse({
-	            data,
-	            path: ctx.path,
-	            parent: ctx,
-	        });
+	class IntegrationLevelDataSourcesListAccessor extends IntegrationLevelElementsListAccessor {
+	    constructor(client, integrationSelector) {
+	        super(client, integrationSelector, 'data-sources');
+	        this.client = client;
+	        this.integrationSelector = integrationSelector;
 	    }
-	    unwrap() {
-	        return this._def.type;
+	}
+	class ConnectionLevelDataSourceAccessor extends ConnectionLevelElementAccessor {
+	    constructor(client, connectionSelector, dataSourceSelector, query) {
+	        super(client, connectionSelector, dataSourceSelector, 'data-sources', query);
+	        this.client = client;
+	        this.connectionSelector = connectionSelector;
+	        this.dataSourceSelector = dataSourceSelector;
+	        this.query = query;
+	    }
+	    async openConfiguration(options) {
+	        var _a;
+	        const instance = await this.get({ autoCreate: true });
+	        const uri = await this.client.getEmbedUri(`data-source-instances/${instance.id}/configuration`);
+	        const onClose = (_a = options === null || options === void 0 ? void 0 : options.onClose) !== null && _a !== void 0 ? _a : (() => { });
+	        return openIframe(uri, { onClose });
 	    }
 	}
-	class ZodPipeline extends ZodType {
-	    _parse(input) {
-	        const { status, ctx } = this._processInputParams(input);
-	        if (ctx.common.async) {
-	            const handleAsync = async () => {
-	                const inResult = await this._def.in._parseAsync({
-	                    data: ctx.data,
-	                    path: ctx.path,
-	                    parent: ctx,
-	                });
-	                if (inResult.status === "aborted")
-	                    return INVALID;
-	                if (inResult.status === "dirty") {
-	                    status.dirty();
-	                    return DIRTY(inResult.value);
-	                }
-	                else {
-	                    return this._def.out._parseAsync({
-	                        data: inResult.value,
-	                        path: ctx.path,
-	                        parent: ctx,
-	                    });
-	                }
-	            };
-	            return handleAsync();
-	        }
-	        else {
-	            const inResult = this._def.in._parseSync({
-	                data: ctx.data,
-	                path: ctx.path,
-	                parent: ctx,
-	            });
-	            if (inResult.status === "aborted")
-	                return INVALID;
-	            if (inResult.status === "dirty") {
-	                status.dirty();
-	                return {
-	                    status: "dirty",
-	                    value: inResult.value,
-	                };
-	            }
-	            else {
-	                return this._def.out._parseSync({
-	                    data: inResult.value,
-	                    path: ctx.path,
-	                    parent: ctx,
-	                });
-	            }
-	        }
+	class ConnectionLevelDataSourcesAccessor extends ConnectionLevelElementsListAccessor {
+	    constructor(client, connectionSelector) {
+	        super(client, connectionSelector, 'data-sources');
+	        this.client = client;
+	        this.connectionSelector = connectionSelector;
 	    }
-	    static create(a, b) {
-	        return new ZodPipeline({
-	            in: a,
-	            out: b,
-	            typeName: ZodFirstPartyTypeKind.ZodPipeline,
+	}
+
+	class FieldMappingInstancesAccessor extends ElementInstanceListAccessor {
+	    constructor(client) {
+	        super(client, 'field-mapping-instances');
+	    }
+	}
+	class FieldMappingInstanceAccessor extends ElementInstanceAccessor {
+	    constructor(client, selector) {
+	        super({
+	            client,
+	            instancePath: 'field-mapping-instance',
+	            selector,
+	        });
+	        this.client = client;
+	    }
+	    async setup() {
+	        const id = await this.getId();
+	        return this.client.post(`/field-mapping-instances/${id}/setup`);
+	    }
+	    async reset() {
+	        const id = await this.getId();
+	        return this.client.post(`/field-mapping-instances/${id}/reset`);
+	    }
+	    async openConfiguration({ onClose = () => { } } = {}) {
+	        const id = await this.getId();
+	        const uri = await this.client.getEmbedUri(`field-mapping-instances/${id}/configuration`);
+	        return openIframe(uri, {
+	            onClose,
 	        });
 	    }
 	}
-	class ZodReadonly extends ZodType {
-	    _parse(input) {
-	        const result = this._def.innerType._parse(input);
-	        const freeze = (data) => {
-	            if (isValid(data)) {
-	                data.value = Object.freeze(data.value);
-	            }
-	            return data;
-	        };
-	        return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
+	class ConnectionLevelFieldMappingAccessor extends ConnectionLevelElementAccessor {
+	    constructor(client, connectionSelector, fieldMappingSelector, query) {
+	        super(client, connectionSelector, fieldMappingSelector, 'field-mappings', query);
+	        this.client = client;
+	        this.connectionSelector = connectionSelector;
+	        this.fieldMappingSelector = fieldMappingSelector;
+	        this.query = query;
 	    }
-	    unwrap() {
-	        return this._def.innerType;
+	    async openConfiguration({ onClose } = {}) {
+	        const instance = await this.get({ autoCreate: true });
+	        const uri = await this.client.getEmbedUri(`field-mapping-instances/${instance.id}/configuration`);
+	        return openIframe(uri, { onClose: onClose !== null && onClose !== void 0 ? onClose : (() => { }) });
+	    }
+	}
+	class ConnectionLevelFieldMappingsAccessor extends ConnectionLevelElementsListAccessor {
+	    constructor(client, connectionSelector) {
+	        super(client, connectionSelector, 'field-mappings');
+	        this.client = client;
+	        this.connectionSelector = connectionSelector;
 	    }
 	}
-	ZodReadonly.create = (type, params) => {
-	    return new ZodReadonly({
-	        innerType: type,
-	        typeName: ZodFirstPartyTypeKind.ZodReadonly,
-	        ...processCreateParams(params),
-	    });
-	};
-	var ZodFirstPartyTypeKind;
-	(function (ZodFirstPartyTypeKind) {
-	    ZodFirstPartyTypeKind["ZodString"] = "ZodString";
-	    ZodFirstPartyTypeKind["ZodNumber"] = "ZodNumber";
-	    ZodFirstPartyTypeKind["ZodNaN"] = "ZodNaN";
-	    ZodFirstPartyTypeKind["ZodBigInt"] = "ZodBigInt";
-	    ZodFirstPartyTypeKind["ZodBoolean"] = "ZodBoolean";
-	    ZodFirstPartyTypeKind["ZodDate"] = "ZodDate";
-	    ZodFirstPartyTypeKind["ZodSymbol"] = "ZodSymbol";
-	    ZodFirstPartyTypeKind["ZodUndefined"] = "ZodUndefined";
-	    ZodFirstPartyTypeKind["ZodNull"] = "ZodNull";
-	    ZodFirstPartyTypeKind["ZodAny"] = "ZodAny";
-	    ZodFirstPartyTypeKind["ZodUnknown"] = "ZodUnknown";
-	    ZodFirstPartyTypeKind["ZodNever"] = "ZodNever";
-	    ZodFirstPartyTypeKind["ZodVoid"] = "ZodVoid";
-	    ZodFirstPartyTypeKind["ZodArray"] = "ZodArray";
-	    ZodFirstPartyTypeKind["ZodObject"] = "ZodObject";
-	    ZodFirstPartyTypeKind["ZodUnion"] = "ZodUnion";
-	    ZodFirstPartyTypeKind["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
-	    ZodFirstPartyTypeKind["ZodIntersection"] = "ZodIntersection";
-	    ZodFirstPartyTypeKind["ZodTuple"] = "ZodTuple";
-	    ZodFirstPartyTypeKind["ZodRecord"] = "ZodRecord";
-	    ZodFirstPartyTypeKind["ZodMap"] = "ZodMap";
-	    ZodFirstPartyTypeKind["ZodSet"] = "ZodSet";
-	    ZodFirstPartyTypeKind["ZodFunction"] = "ZodFunction";
-	    ZodFirstPartyTypeKind["ZodLazy"] = "ZodLazy";
-	    ZodFirstPartyTypeKind["ZodLiteral"] = "ZodLiteral";
-	    ZodFirstPartyTypeKind["ZodEnum"] = "ZodEnum";
-	    ZodFirstPartyTypeKind["ZodEffects"] = "ZodEffects";
-	    ZodFirstPartyTypeKind["ZodNativeEnum"] = "ZodNativeEnum";
-	    ZodFirstPartyTypeKind["ZodOptional"] = "ZodOptional";
-	    ZodFirstPartyTypeKind["ZodNullable"] = "ZodNullable";
-	    ZodFirstPartyTypeKind["ZodDefault"] = "ZodDefault";
-	    ZodFirstPartyTypeKind["ZodCatch"] = "ZodCatch";
-	    ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise";
-	    ZodFirstPartyTypeKind["ZodBranded"] = "ZodBranded";
-	    ZodFirstPartyTypeKind["ZodPipeline"] = "ZodPipeline";
-	    ZodFirstPartyTypeKind["ZodReadonly"] = "ZodReadonly";
-	})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-	const stringType = ZodString.create;
-	const anyType = ZodAny.create;
-	ZodNever.create;
-	const arrayType = ZodArray.create;
-	const objectType = ZodObject.create;
-	ZodUnion.create;
-	ZodIntersection.create;
-	ZodTuple.create;
-	const lazyType = ZodLazy.create;
-	ZodEnum.create;
-	const nativeEnumType = ZodNativeEnum.create;
-	ZodPromise.create;
-	ZodOptional.create;
-	ZodNullable.create;
 
 	var ErrorType;
 	(function (ErrorType) {
@@ -16144,6 +16265,13 @@
 	    async delete(uri, data, options) {
 	        return this.makeApiRequest('DELETE', { ...(options !== null && options !== void 0 ? options : {}), url: uri, data });
 	    }
+	    async createEventSource(uri, queryParams) {
+	        const token = await this.getToken();
+	        const allParams = { ...queryParams, token };
+	        const queryString = qs.stringify(omitBy(allParams, isEmptyValue));
+	        const urlWithToken = `${this.apiUri}/${uri}?${queryString}`;
+	        return new EventSource(urlWithToken);
+	    }
 	    async getEmbedUri(page, pageParams, options) {
 	        var _a;
 	        const paramsWithToken = {
@@ -16336,6 +16464,9 @@
 	    get scenarios() {
 	        return new ScenariosAccessor(this);
 	    }
+	    async createEventSource(uri, queryParams) {
+	        return super.createEventSource(uri, queryParams);
+	    }
 	    async connectionRequest(connectionId, uri, data) {
 	        return this.post(`connections/${connectionId}/execute-request`, {
 	            key: uri,