@atlanai/sdk 0.1.1 → 0.2.2

package/dist/raw/registry/apis/OrganisationsApi.d.ts

@@ -12,11 +12,18 @@
 import * as runtime from '../runtime';
 import { type OrganisationDto } from '../models/OrganisationDto';
 import { type OrganisationsPage } from '../models/OrganisationsPage';
+import { type SetTraceContentPolicyDto } from '../models/SetTraceContentPolicyDto';
+import { type TraceContentPolicyDto } from '../models/TraceContentPolicyDto';
 export interface RegistryGetOrganisationRequest {
     orgId: string;
 }
 export interface RegistryQueryOrganisationTraceStatsRequest {
     body: any | null;
+    contentEncoding?: RegistryQueryOrganisationTraceStatsContentEncodingEnum;
+}
+export interface RegistrySetTraceContentPolicyRequest {
+    setTraceContentPolicyDto: SetTraceContentPolicyDto;
+    contentEncoding?: RegistrySetTraceContentPolicyContentEncodingEnum;
 }
 /**
  *
@@ -36,6 +43,20 @@ export declare class OrganisationsApi extends runtime.BaseAPI {
      * Get an organisation
      */
     registryGetOrganisation(requestParameters: RegistryGetOrganisationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OrganisationDto>;
+    /**
+     * Creates request options for registryGetTraceContentPolicy without sending the request
+     */
+    registryGetTraceContentPolicyRequestOpts(): Promise<runtime.RequestOpts>;
+    /**
+     * A document of facets, one field per facet — `capture` today; retention and redaction configuration are the named next ones, each arriving as an additive field. `capture`: `store` admits the content half of an ingested trace into the content plane, `drop` discards it at the worker, and `null` means the account never chose — which resolves as `drop`, the fail-closed default. Readable by any member: clients strip content at emit when the effective capture is `drop`, so this is the login-time read that makes that possible.
+     * Get the account\'s trace-content policy
+     */
+    registryGetTraceContentPolicyRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TraceContentPolicyDto>>;
+    /**
+     * A document of facets, one field per facet — `capture` today; retention and redaction configuration are the named next ones, each arriving as an additive field. `capture`: `store` admits the content half of an ingested trace into the content plane, `drop` discards it at the worker, and `null` means the account never chose — which resolves as `drop`, the fail-closed default. Readable by any member: clients strip content at emit when the effective capture is `drop`, so this is the login-time read that makes that possible.
+     * Get the account\'s trace-content policy
+     */
+    registryGetTraceContentPolicy(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TraceContentPolicyDto>;
     /**
      * Creates request options for registryListOrganisations without sending the request
      */
@@ -64,4 +85,34 @@ export declare class OrganisationsApi extends runtime.BaseAPI {
      * Trace statistics across the whole account
      */
     registryQueryOrganisationTraceStats(requestParameters: RegistryQueryOrganisationTraceStatsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any>;
+    /**
+     * Creates request options for registrySetTraceContentPolicy without sending the request
+     */
+    registrySetTraceContentPolicyRequestOpts(requestParameters: RegistrySetTraceContentPolicyRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Org-admin: account-wide capture posture is exactly the class of decision the org-admin tier exists for. A patch of facets: only fields present in the body change, so a caller setting `capture` is untouched by facets added later. `capture`: `store` or `drop`; `null` clears the choice back to the fail-closed default — behaviourally identical to `drop`, kept distinct because \"never chose\" and \"chose drop\" are different facts. Audited under the policy\'s own entity type. Every facet is a ceiling: it can only narrow what a client already decided, never resurrect content a client stripped.
+     * Set the account\'s trace-content policy
+     */
+    registrySetTraceContentPolicyRaw(requestParameters: RegistrySetTraceContentPolicyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TraceContentPolicyDto>>;
+    /**
+     * Org-admin: account-wide capture posture is exactly the class of decision the org-admin tier exists for. A patch of facets: only fields present in the body change, so a caller setting `capture` is untouched by facets added later. `capture`: `store` or `drop`; `null` clears the choice back to the fail-closed default — behaviourally identical to `drop`, kept distinct because \"never chose\" and \"chose drop\" are different facts. Audited under the policy\'s own entity type. Every facet is a ceiling: it can only narrow what a client already decided, never resurrect content a client stripped.
+     * Set the account\'s trace-content policy
+     */
+    registrySetTraceContentPolicy(requestParameters: RegistrySetTraceContentPolicyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TraceContentPolicyDto>;
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum RegistryQueryOrganisationTraceStatsContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum RegistrySetTraceContentPolicyContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
 }

package/dist/raw/registry/apis/OrganisationsApi.js

@@ -46,10 +46,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrganisationsApi = void 0;
+exports.RegistrySetTraceContentPolicyContentEncodingEnum = exports.RegistryQueryOrganisationTraceStatsContentEncodingEnum = exports.OrganisationsApi = void 0;
 const runtime = __importStar(require("../runtime"));
 const OrganisationDto_1 = require("../models/OrganisationDto");
 const OrganisationsPage_1 = require("../models/OrganisationsPage");
+const SetTraceContentPolicyDto_1 = require("../models/SetTraceContentPolicyDto");
+const TraceContentPolicyDto_1 = require("../models/TraceContentPolicyDto");
 /**
  *
  */
@@ -96,6 +98,44 @@ class OrganisationsApi extends runtime.BaseAPI {
         const response = await this.registryGetOrganisationRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for registryGetTraceContentPolicy without sending the request
+     */
+    async registryGetTraceContentPolicyRequestOpts() {
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/organisations/trace-content-policy`;
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * A document of facets, one field per facet — `capture` today; retention and redaction configuration are the named next ones, each arriving as an additive field. `capture`: `store` admits the content half of an ingested trace into the content plane, `drop` discards it at the worker, and `null` means the account never chose — which resolves as `drop`, the fail-closed default. Readable by any member: clients strip content at emit when the effective capture is `drop`, so this is the login-time read that makes that possible.
+     * Get the account\'s trace-content policy
+     */
+    async registryGetTraceContentPolicyRaw(initOverrides) {
+        const requestOptions = await this.registryGetTraceContentPolicyRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, TraceContentPolicyDto_1.TraceContentPolicyDtoFromJSON)(jsonValue));
+    }
+    /**
+     * A document of facets, one field per facet — `capture` today; retention and redaction configuration are the named next ones, each arriving as an additive field. `capture`: `store` admits the content half of an ingested trace into the content plane, `drop` discards it at the worker, and `null` means the account never chose — which resolves as `drop`, the fail-closed default. Readable by any member: clients strip content at emit when the effective capture is `drop`, so this is the login-time read that makes that possible.
+     * Get the account\'s trace-content policy
+     */
+    async registryGetTraceContentPolicy(initOverrides) {
+        const response = await this.registryGetTraceContentPolicyRaw(initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for registryListOrganisations without sending the request
      */
@@ -144,6 +184,9 @@ class OrganisationsApi extends runtime.BaseAPI {
         const queryParameters = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['contentEncoding'] != null) {
+            headerParameters['Content-Encoding'] = String(requestParameters['contentEncoding']);
+        }
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearer", []);
@@ -182,5 +225,69 @@ class OrganisationsApi extends runtime.BaseAPI {
         const response = await this.registryQueryOrganisationTraceStatsRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for registrySetTraceContentPolicy without sending the request
+     */
+    async registrySetTraceContentPolicyRequestOpts(requestParameters) {
+        if (requestParameters['setTraceContentPolicyDto'] == null) {
+            throw new runtime.RequiredError('setTraceContentPolicyDto', 'Required parameter "setTraceContentPolicyDto" was null or undefined when calling registrySetTraceContentPolicy().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['contentEncoding'] != null) {
+            headerParameters['Content-Encoding'] = String(requestParameters['contentEncoding']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/organisations/trace-content-policy`;
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, SetTraceContentPolicyDto_1.SetTraceContentPolicyDtoToJSON)(requestParameters['setTraceContentPolicyDto']),
+        };
+    }
+    /**
+     * Org-admin: account-wide capture posture is exactly the class of decision the org-admin tier exists for. A patch of facets: only fields present in the body change, so a caller setting `capture` is untouched by facets added later. `capture`: `store` or `drop`; `null` clears the choice back to the fail-closed default — behaviourally identical to `drop`, kept distinct because \"never chose\" and \"chose drop\" are different facts. Audited under the policy\'s own entity type. Every facet is a ceiling: it can only narrow what a client already decided, never resurrect content a client stripped.
+     * Set the account\'s trace-content policy
+     */
+    async registrySetTraceContentPolicyRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.registrySetTraceContentPolicyRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, TraceContentPolicyDto_1.TraceContentPolicyDtoFromJSON)(jsonValue));
+    }
+    /**
+     * Org-admin: account-wide capture posture is exactly the class of decision the org-admin tier exists for. A patch of facets: only fields present in the body change, so a caller setting `capture` is untouched by facets added later. `capture`: `store` or `drop`; `null` clears the choice back to the fail-closed default — behaviourally identical to `drop`, kept distinct because \"never chose\" and \"chose drop\" are different facts. Audited under the policy\'s own entity type. Every facet is a ceiling: it can only narrow what a client already decided, never resurrect content a client stripped.
+     * Set the account\'s trace-content policy
+     */
+    async registrySetTraceContentPolicy(requestParameters, initOverrides) {
+        const response = await this.registrySetTraceContentPolicyRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
 }
 exports.OrganisationsApi = OrganisationsApi;
+/**
+  * @export
+  * @enum {string}
+  */
+var RegistryQueryOrganisationTraceStatsContentEncodingEnum;
+(function (RegistryQueryOrganisationTraceStatsContentEncodingEnum) {
+    RegistryQueryOrganisationTraceStatsContentEncodingEnum["Base64"] = "base64";
+    RegistryQueryOrganisationTraceStatsContentEncodingEnum["GzipBase64"] = "gzip, base64";
+})(RegistryQueryOrganisationTraceStatsContentEncodingEnum || (exports.RegistryQueryOrganisationTraceStatsContentEncodingEnum = RegistryQueryOrganisationTraceStatsContentEncodingEnum = {}));
+/**
+  * @export
+  * @enum {string}
+  */
+var RegistrySetTraceContentPolicyContentEncodingEnum;
+(function (RegistrySetTraceContentPolicyContentEncodingEnum) {
+    RegistrySetTraceContentPolicyContentEncodingEnum["Base64"] = "base64";
+    RegistrySetTraceContentPolicyContentEncodingEnum["GzipBase64"] = "gzip, base64";
+})(RegistrySetTraceContentPolicyContentEncodingEnum || (exports.RegistrySetTraceContentPolicyContentEncodingEnum = RegistrySetTraceContentPolicyContentEncodingEnum = {}));

package/dist/raw/registry/apis/ReleasesApi.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Atlan Agent Gateway — registry
+ * The platform core: identity, tenancy, the artifact plane, discovery and the policy plane.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime';
+import { type CutReleaseBody } from '../models/CutReleaseBody';
+import { type ReleaseDto } from '../models/ReleaseDto';
+import { type ReleasePage } from '../models/ReleasePage';
+import { type ReleasePolicyDto } from '../models/ReleasePolicyDto';
+import { type SetReleasePolicyBody } from '../models/SetReleasePolicyBody';
+import { type WithdrawBody } from '../models/WithdrawBody';
+export interface RegistryCutReleaseRequest {
+    artifactKind: string;
+    artifactId: string;
+    cutReleaseBody: CutReleaseBody;
+    contentEncoding?: RegistryCutReleaseContentEncodingEnum;
+}
+export interface RegistryGetCurrentReleaseRequest {
+    artifactKind: string;
+    artifactId: string;
+    channel: string;
+}
+export interface RegistryGetReleasePolicyRequest {
+    workspaceId: string;
+    channel: string;
+}
+export interface RegistryListArtifactChannelsRequest {
+    artifactKind: string;
+    artifactId: string;
+}
+export interface RegistryListArtifactReleasesRequest {
+    artifactKind: string;
+    artifactId: string;
+    limit?: number | null;
+    offset?: number | null;
+}
+export interface RegistryListReleasesRequest {
+    limit?: number | null;
+    offset?: number | null;
+}
+export interface RegistrySetReleasePolicyRequest {
+    workspaceId: string;
+    channel: string;
+    setReleasePolicyBody: SetReleasePolicyBody;
+    contentEncoding?: RegistrySetReleasePolicyContentEncodingEnum;
+}
+export interface RegistryWithdrawReleaseRequest {
+    releaseId: string;
+    withdrawBody: WithdrawBody;
+    contentEncoding?: RegistryWithdrawReleaseContentEncodingEnum;
+}
+/**
+ *
+ */
+export declare class ReleasesApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for registryCutRelease without sending the request
+     */
+    registryCutReleaseRequestOpts(requestParameters: RegistryCutReleaseRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Ships one version of one artifact line on one channel. Absent `version_id` takes the line\'s head; absent `channel` takes the account\'s default channel (`latest`).          The published **number** and the **semver** are allocated here, not at write time — a version that has never been released has neither, which is the whole reason they live on the release. An absent `version_label` auto-bumps the line\'s minor.  Requires `manage` on the artifact\'s workspace, or `update` plus being the artifact\'s owner. A machine-created artifact has no owner, so only the admin arm applies to it.
+     * Release a version onto a channel
+     */
+    registryCutReleaseRaw(requestParameters: RegistryCutReleaseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ReleaseDto>>;
+    /**
+     * Ships one version of one artifact line on one channel. Absent `version_id` takes the line\'s head; absent `channel` takes the account\'s default channel (`latest`).          The published **number** and the **semver** are allocated here, not at write time — a version that has never been released has neither, which is the whole reason they live on the release. An absent `version_label` auto-bumps the line\'s minor.  Requires `manage` on the artifact\'s workspace, or `update` plus being the artifact\'s owner. A machine-created artifact has no owner, so only the admin arm applies to it.
+     * Release a version onto a channel
+     */
+    registryCutRelease(requestParameters: RegistryCutReleaseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ReleaseDto>;
+    /**
+     * Creates request options for registryGetCurrentRelease without sending the request
+     */
+    registryGetCurrentReleaseRequestOpts(requestParameters: RegistryGetCurrentReleaseRequest): Promise<runtime.RequestOpts>;
+    /**
+     * What `<artifact>@<channel>` means — the version every distribution surface serves for this line on this channel. `404` when the channel has never shipped, which is distinct from the channel not existing.
+     * Resolve a channel\'s current release
+     */
+    registryGetCurrentReleaseRaw(requestParameters: RegistryGetCurrentReleaseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ReleaseDto>>;
+    /**
+     * What `<artifact>@<channel>` means — the version every distribution surface serves for this line on this channel. `404` when the channel has never shipped, which is distinct from the channel not existing.
+     * Resolve a channel\'s current release
+     */
+    registryGetCurrentRelease(requestParameters: RegistryGetCurrentReleaseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ReleaseDto>;
+    /**
+     * Creates request options for registryGetReleasePolicy without sending the request
+     */
+    registryGetReleasePolicyRequestOpts(requestParameters: RegistryGetReleasePolicyRequest): Promise<runtime.RequestOpts>;
+    /**
+     * The **resolved** policy, not the stored row: exact `(workspace, channel)` row, else the channel\'s own definition, else the fail-safe default. `resolved_from` says which level answered.  There is deliberately no inheritance from a parent workspace — a caller holding `read` on a child may hold nothing on its parent, so an inheriting resolver would either spend receipts it cannot get or read ancestor rows ungoverned.
+     * Read a workspace\'s resolved release policy for a channel
+     */
+    registryGetReleasePolicyRaw(requestParameters: RegistryGetReleasePolicyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ReleasePolicyDto>>;
+    /**
+     * The **resolved** policy, not the stored row: exact `(workspace, channel)` row, else the channel\'s own definition, else the fail-safe default. `resolved_from` says which level answered.  There is deliberately no inheritance from a parent workspace — a caller holding `read` on a child may hold nothing on its parent, so an inheriting resolver would either spend receipts it cannot get or read ancestor rows ungoverned.
+     * Read a workspace\'s resolved release policy for a channel
+     */
+    registryGetReleasePolicy(requestParameters: RegistryGetReleasePolicyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ReleasePolicyDto>;
+    /**
+     * Creates request options for registryListArtifactChannels without sending the request
+     */
+    registryListArtifactChannelsRequestOpts(requestParameters: RegistryListArtifactChannelsRequest): Promise<runtime.RequestOpts>;
+    /**
+     * One entry per channel with a current release — the \"what betas exist\" read, so an agent can discover `@beta` without guessing the slug.
+     * List the channels this artifact currently ships on
+     */
+    registryListArtifactChannelsRaw(requestParameters: RegistryListArtifactChannelsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * One entry per channel with a current release — the \"what betas exist\" read, so an agent can discover `@beta` without guessing the slug.
+     * List the channels this artifact currently ships on
+     */
+    registryListArtifactChannels(requestParameters: RegistryListArtifactChannelsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for registryListArtifactReleases without sending the request
+     */
+    registryListArtifactReleasesRequestOpts(requestParameters: RegistryListArtifactReleasesRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Newest first, every status included — `withdrawn` among them, because a shipping record that hid its own retractions would be the wrong record.  Paged: `limit` defaults to 50 and is clamped to 500. A line seeded by the release migration has one row per version it ever had.
+     * List one artifact\'s release history
+     */
+    registryListArtifactReleasesRaw(requestParameters: RegistryListArtifactReleasesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ReleasePage>>;
+    /**
+     * Newest first, every status included — `withdrawn` among them, because a shipping record that hid its own retractions would be the wrong record.  Paged: `limit` defaults to 50 and is clamped to 500. A line seeded by the release migration has one row per version it ever had.
+     * List one artifact\'s release history
+     */
+    registryListArtifactReleases(requestParameters: RegistryListArtifactReleasesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ReleasePage>;
+    /**
+     * Creates request options for registryListReleases without sending the request
+     */
+    registryListReleasesRequestOpts(requestParameters: RegistryListReleasesRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Every release the caller can read, newest first. Scoped to the caller\'s readable workspace set the way `/action-runs` is, so a release in a workspace the caller holds no role on is absent rather than refused.  Every status is included, `withdrawn` among them: a shipping record that hid its own retractions would be the wrong record.  Paged: `limit` defaults to 50 and is clamped to 500. The migration that created this table seeded a row per version of every artifact, so an account\'s full history is large.
+     * List releases
+     */
+    registryListReleasesRaw(requestParameters: RegistryListReleasesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ReleasePage>>;
+    /**
+     * Every release the caller can read, newest first. Scoped to the caller\'s readable workspace set the way `/action-runs` is, so a release in a workspace the caller holds no role on is absent rather than refused.  Every status is included, `withdrawn` among them: a shipping record that hid its own retractions would be the wrong record.  Paged: `limit` defaults to 50 and is clamped to 500. The migration that created this table seeded a row per version of every artifact, so an account\'s full history is large.
+     * List releases
+     */
+    registryListReleases(requestParameters?: RegistryListReleasesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ReleasePage>;
+    /**
+     * Creates request options for registrySetReleasePolicy without sending the request
+     */
+    registrySetReleasePolicyRequestOpts(requestParameters: RegistrySetReleasePolicyRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Requires **`manage`** on the workspace — workspace admins only. Not `update`: a member who may edit an artifact is not thereby a member who may decide whether artifacts ship.  Every facet is a double option — absent leaves it alone, `null` clears it back to deferring to the channel, a value sets it. A workspace cannot raise the channel\'s `allow_public` ceiling; asking for `public` where the org has not opened it resolves back to `private`.
+     * Set a workspace\'s release policy for a channel
+     */
+    registrySetReleasePolicyRaw(requestParameters: RegistrySetReleasePolicyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ReleasePolicyDto>>;
+    /**
+     * Requires **`manage`** on the workspace — workspace admins only. Not `update`: a member who may edit an artifact is not thereby a member who may decide whether artifacts ship.  Every facet is a double option — absent leaves it alone, `null` clears it back to deferring to the channel, a value sets it. A workspace cannot raise the channel\'s `allow_public` ceiling; asking for `public` where the org has not opened it resolves back to `private`.
+     * Set a workspace\'s release policy for a channel
+     */
+    registrySetReleasePolicy(requestParameters: RegistrySetReleasePolicyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ReleasePolicyDto>;
+    /**
+     * Creates request options for registryWithdrawRelease without sending the request
+     */
+    registryWithdrawReleaseRequestOpts(requestParameters: RegistryWithdrawReleaseRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Unship a release. If it was the channel\'s current one, the previous non-withdrawn release on that channel is promoted back — a channel with nothing current on it breaks every consumer that resolves it, which is the opposite of `POST …/archive`, where the whole line is terminal and there is nothing to promote to.  A **pending** release may be withdrawn too, and this is the only way to clear one: a pending row holds its line\'s release slot, so one that nothing settles blocks every later version of that line. It never shipped, so nothing is promoted back.  Requires `manage` on the release\'s workspace, or `update` plus being the artifact\'s owner.
+     * Withdraw a release
+     */
+    registryWithdrawReleaseRaw(requestParameters: RegistryWithdrawReleaseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ReleaseDto>>;
+    /**
+     * Unship a release. If it was the channel\'s current one, the previous non-withdrawn release on that channel is promoted back — a channel with nothing current on it breaks every consumer that resolves it, which is the opposite of `POST …/archive`, where the whole line is terminal and there is nothing to promote to.  A **pending** release may be withdrawn too, and this is the only way to clear one: a pending row holds its line\'s release slot, so one that nothing settles blocks every later version of that line. It never shipped, so nothing is promoted back.  Requires `manage` on the release\'s workspace, or `update` plus being the artifact\'s owner.
+     * Withdraw a release
+     */
+    registryWithdrawRelease(requestParameters: RegistryWithdrawReleaseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ReleaseDto>;
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum RegistryCutReleaseContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum RegistrySetReleasePolicyContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}
+/**
+  * @export
+  * @enum {string}
+  */
+export declare enum RegistryWithdrawReleaseContentEncodingEnum {
+    Base64 = "base64",
+    GzipBase64 = "gzip, base64"
+}