@cdktf-providers/astronomer-astro 1.0.8

package/dist/hybrid-cluster-workspace-authorization/index.d.ts

@@ -0,0 +1,53 @@
+import { Construct } from 'constructs';
+import * as cdktf from 'cdktf';
+export interface HybridClusterWorkspaceAuthorizationConfig extends cdktf.TerraformMetaArguments {
+    /**
+    * The ID of the hybrid cluster to set authorizations for
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/hybrid_cluster_workspace_authorization#cluster_id HybridClusterWorkspaceAuthorization#cluster_id}
+    */
+    readonly clusterId: string;
+    /**
+    * The IDs of the workspaces to authorize for the hybrid cluster
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/hybrid_cluster_workspace_authorization#workspace_ids HybridClusterWorkspaceAuthorization#workspace_ids}
+    */
+    readonly workspaceIds?: string[];
+}
+/**
+* Represents a {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/hybrid_cluster_workspace_authorization astro_hybrid_cluster_workspace_authorization}
+*/
+export declare class HybridClusterWorkspaceAuthorization extends cdktf.TerraformResource {
+    static readonly tfResourceType = "astro_hybrid_cluster_workspace_authorization";
+    /**
+    * Generates CDKTF code for importing a HybridClusterWorkspaceAuthorization resource upon running "cdktf plan <stack-name>"
+    * @param scope The scope in which to define this construct
+    * @param importToId The construct id used in the generated config for the HybridClusterWorkspaceAuthorization to import
+    * @param importFromId The id of the existing HybridClusterWorkspaceAuthorization that should be imported. Refer to the {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/hybrid_cluster_workspace_authorization#import import section} in the documentation of this resource for the id to use
+    * @param provider? Optional instance of the provider where the HybridClusterWorkspaceAuthorization to import is found
+    */
+    static generateConfigForImport(scope: Construct, importToId: string, importFromId: string, provider?: cdktf.TerraformProvider): any;
+    /**
+    * Create a new {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/hybrid_cluster_workspace_authorization astro_hybrid_cluster_workspace_authorization} Resource
+    *
+    * @param scope The scope in which to define this construct
+    * @param id The scoped construct ID. Must be unique amongst siblings in the same scope
+    * @param options HybridClusterWorkspaceAuthorizationConfig
+    */
+    constructor(scope: Construct, id: string, config: HybridClusterWorkspaceAuthorizationConfig);
+    private _clusterId?;
+    get clusterId(): string;
+    set clusterId(value: string);
+    get clusterIdInput(): string;
+    private _workspaceIds?;
+    get workspaceIds(): string[];
+    set workspaceIds(value: string[]);
+    resetWorkspaceIds(): void;
+    get workspaceIdsInput(): string[];
+    protected synthesizeAttributes(): {
+        [name: string]: any;
+    };
+    protected synthesizeHclAttributes(): {
+        [name: string]: any;
+    };
+}

package/dist/hybrid-cluster-workspace-authorization/index.js

@@ -0,0 +1,111 @@
+// https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/hybrid_cluster_workspace_authorization
+// generated from terraform resource schema
+import * as cdktf from 'cdktf';
+/**
+* Represents a {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/hybrid_cluster_workspace_authorization astro_hybrid_cluster_workspace_authorization}
+*/
+export class HybridClusterWorkspaceAuthorization extends cdktf.TerraformResource {
+    // =================
+    // STATIC PROPERTIES
+    // =================
+    static tfResourceType = "astro_hybrid_cluster_workspace_authorization";
+    // ==============
+    // STATIC Methods
+    // ==============
+    /**
+    * Generates CDKTF code for importing a HybridClusterWorkspaceAuthorization resource upon running "cdktf plan <stack-name>"
+    * @param scope The scope in which to define this construct
+    * @param importToId The construct id used in the generated config for the HybridClusterWorkspaceAuthorization to import
+    * @param importFromId The id of the existing HybridClusterWorkspaceAuthorization that should be imported. Refer to the {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/hybrid_cluster_workspace_authorization#import import section} in the documentation of this resource for the id to use
+    * @param provider? Optional instance of the provider where the HybridClusterWorkspaceAuthorization to import is found
+    */
+    static generateConfigForImport(scope, importToId, importFromId, provider) {
+        return new cdktf.ImportableResource(scope, importToId, { terraformResourceType: "astro_hybrid_cluster_workspace_authorization", importId: importFromId, provider });
+    }
+    // ===========
+    // INITIALIZER
+    // ===========
+    /**
+    * Create a new {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/hybrid_cluster_workspace_authorization astro_hybrid_cluster_workspace_authorization} Resource
+    *
+    * @param scope The scope in which to define this construct
+    * @param id The scoped construct ID. Must be unique amongst siblings in the same scope
+    * @param options HybridClusterWorkspaceAuthorizationConfig
+    */
+    constructor(scope, id, config) {
+        super(scope, id, {
+            terraformResourceType: 'astro_hybrid_cluster_workspace_authorization',
+            terraformGeneratorMetadata: {
+                providerName: 'astro',
+                providerVersion: '1.0.8',
+                providerVersionConstraint: '1.0.8'
+            },
+            provider: config.provider,
+            dependsOn: config.dependsOn,
+            count: config.count,
+            lifecycle: config.lifecycle,
+            provisioners: config.provisioners,
+            connection: config.connection,
+            forEach: config.forEach
+        });
+        this._clusterId = config.clusterId;
+        this._workspaceIds = config.workspaceIds;
+    }
+    // ==========
+    // ATTRIBUTES
+    // ==========
+    // cluster_id - computed: false, optional: false, required: true
+    _clusterId;
+    get clusterId() {
+        return this.getStringAttribute('cluster_id');
+    }
+    set clusterId(value) {
+        this._clusterId = value;
+    }
+    // Temporarily expose input value. Use with caution.
+    get clusterIdInput() {
+        return this._clusterId;
+    }
+    // workspace_ids - computed: false, optional: true, required: false
+    _workspaceIds;
+    get workspaceIds() {
+        return cdktf.Fn.tolist(this.getListAttribute('workspace_ids'));
+    }
+    set workspaceIds(value) {
+        this._workspaceIds = value;
+    }
+    resetWorkspaceIds() {
+        this._workspaceIds = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get workspaceIdsInput() {
+        return this._workspaceIds;
+    }
+    // =========
+    // SYNTHESIS
+    // =========
+    synthesizeAttributes() {
+        return {
+            cluster_id: cdktf.stringToTerraform(this._clusterId),
+            workspace_ids: cdktf.listMapper(cdktf.stringToTerraform, false)(this._workspaceIds),
+        };
+    }
+    synthesizeHclAttributes() {
+        const attrs = {
+            cluster_id: {
+                value: cdktf.stringToHclTerraform(this._clusterId),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+            workspace_ids: {
+                value: cdktf.listMapperHcl(cdktf.stringToHclTerraform, false)(this._workspaceIds),
+                isBlock: false,
+                type: "set",
+                storageClassType: "stringList",
+            },
+        };
+        // remove undefined attributes
+        return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined));
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export * as alert from './alert';
+export * as apiToken from './api-token';
+export * as cluster from './cluster';
+export * as deployment from './deployment';
+export * as hybridClusterWorkspaceAuthorization from './hybrid-cluster-workspace-authorization';
+export * as notificationChannel from './notification-channel';
+export * as team from './team';
+export * as teamRoles from './team-roles';
+export * as userInvite from './user-invite';
+export * as userRoles from './user-roles';
+export * as workspace from './workspace';
+export * as dataAstroAlert from './data-astro-alert';
+export * as dataAstroAlerts from './data-astro-alerts';
+export * as dataAstroApiToken from './data-astro-api-token';
+export * as dataAstroApiTokens from './data-astro-api-tokens';
+export * as dataAstroCluster from './data-astro-cluster';
+export * as dataAstroClusterOptions from './data-astro-cluster-options';
+export * as dataAstroClusters from './data-astro-clusters';
+export * as dataAstroDeployment from './data-astro-deployment';
+export * as dataAstroDeploymentOptions from './data-astro-deployment-options';
+export * as dataAstroDeployments from './data-astro-deployments';
+export * as dataAstroNotificationChannel from './data-astro-notification-channel';
+export * as dataAstroNotificationChannels from './data-astro-notification-channels';
+export * as dataAstroOrganization from './data-astro-organization';
+export * as dataAstroTeam from './data-astro-team';
+export * as dataAstroTeams from './data-astro-teams';
+export * as dataAstroUser from './data-astro-user';
+export * as dataAstroUsers from './data-astro-users';
+export * as dataAstroWorkspace from './data-astro-workspace';
+export * as dataAstroWorkspaces from './data-astro-workspaces';
+export * as provider from './provider';

package/dist/index.js

@@ -0,0 +1,32 @@
+// generated by cdktf get
+export * as alert from './alert';
+export * as apiToken from './api-token';
+export * as cluster from './cluster';
+export * as deployment from './deployment';
+export * as hybridClusterWorkspaceAuthorization from './hybrid-cluster-workspace-authorization';
+export * as notificationChannel from './notification-channel';
+export * as team from './team';
+export * as teamRoles from './team-roles';
+export * as userInvite from './user-invite';
+export * as userRoles from './user-roles';
+export * as workspace from './workspace';
+export * as dataAstroAlert from './data-astro-alert';
+export * as dataAstroAlerts from './data-astro-alerts';
+export * as dataAstroApiToken from './data-astro-api-token';
+export * as dataAstroApiTokens from './data-astro-api-tokens';
+export * as dataAstroCluster from './data-astro-cluster';
+export * as dataAstroClusterOptions from './data-astro-cluster-options';
+export * as dataAstroClusters from './data-astro-clusters';
+export * as dataAstroDeployment from './data-astro-deployment';
+export * as dataAstroDeploymentOptions from './data-astro-deployment-options';
+export * as dataAstroDeployments from './data-astro-deployments';
+export * as dataAstroNotificationChannel from './data-astro-notification-channel';
+export * as dataAstroNotificationChannels from './data-astro-notification-channels';
+export * as dataAstroOrganization from './data-astro-organization';
+export * as dataAstroTeam from './data-astro-team';
+export * as dataAstroTeams from './data-astro-teams';
+export * as dataAstroUser from './data-astro-user';
+export * as dataAstroUsers from './data-astro-users';
+export * as dataAstroWorkspace from './data-astro-workspace';
+export * as dataAstroWorkspaces from './data-astro-workspaces';
+export * as provider from './provider';

package/dist/lazy-index.js

@@ -0,0 +1,32 @@
+// generated by cdktf get
+Object.defineProperty(exports, 'alert', { get: function () { return require('./alert'); } });
+Object.defineProperty(exports, 'apiToken', { get: function () { return require('./api-token'); } });
+Object.defineProperty(exports, 'cluster', { get: function () { return require('./cluster'); } });
+Object.defineProperty(exports, 'deployment', { get: function () { return require('./deployment'); } });
+Object.defineProperty(exports, 'hybridClusterWorkspaceAuthorization', { get: function () { return require('./hybrid-cluster-workspace-authorization'); } });
+Object.defineProperty(exports, 'notificationChannel', { get: function () { return require('./notification-channel'); } });
+Object.defineProperty(exports, 'team', { get: function () { return require('./team'); } });
+Object.defineProperty(exports, 'teamRoles', { get: function () { return require('./team-roles'); } });
+Object.defineProperty(exports, 'userInvite', { get: function () { return require('./user-invite'); } });
+Object.defineProperty(exports, 'userRoles', { get: function () { return require('./user-roles'); } });
+Object.defineProperty(exports, 'workspace', { get: function () { return require('./workspace'); } });
+Object.defineProperty(exports, 'dataAstroAlert', { get: function () { return require('./data-astro-alert'); } });
+Object.defineProperty(exports, 'dataAstroAlerts', { get: function () { return require('./data-astro-alerts'); } });
+Object.defineProperty(exports, 'dataAstroApiToken', { get: function () { return require('./data-astro-api-token'); } });
+Object.defineProperty(exports, 'dataAstroApiTokens', { get: function () { return require('./data-astro-api-tokens'); } });
+Object.defineProperty(exports, 'dataAstroCluster', { get: function () { return require('./data-astro-cluster'); } });
+Object.defineProperty(exports, 'dataAstroClusterOptions', { get: function () { return require('./data-astro-cluster-options'); } });
+Object.defineProperty(exports, 'dataAstroClusters', { get: function () { return require('./data-astro-clusters'); } });
+Object.defineProperty(exports, 'dataAstroDeployment', { get: function () { return require('./data-astro-deployment'); } });
+Object.defineProperty(exports, 'dataAstroDeploymentOptions', { get: function () { return require('./data-astro-deployment-options'); } });
+Object.defineProperty(exports, 'dataAstroDeployments', { get: function () { return require('./data-astro-deployments'); } });
+Object.defineProperty(exports, 'dataAstroNotificationChannel', { get: function () { return require('./data-astro-notification-channel'); } });
+Object.defineProperty(exports, 'dataAstroNotificationChannels', { get: function () { return require('./data-astro-notification-channels'); } });
+Object.defineProperty(exports, 'dataAstroOrganization', { get: function () { return require('./data-astro-organization'); } });
+Object.defineProperty(exports, 'dataAstroTeam', { get: function () { return require('./data-astro-team'); } });
+Object.defineProperty(exports, 'dataAstroTeams', { get: function () { return require('./data-astro-teams'); } });
+Object.defineProperty(exports, 'dataAstroUser', { get: function () { return require('./data-astro-user'); } });
+Object.defineProperty(exports, 'dataAstroUsers', { get: function () { return require('./data-astro-users'); } });
+Object.defineProperty(exports, 'dataAstroWorkspace', { get: function () { return require('./data-astro-workspace'); } });
+Object.defineProperty(exports, 'dataAstroWorkspaces', { get: function () { return require('./data-astro-workspaces'); } });
+Object.defineProperty(exports, 'provider', { get: function () { return require('./provider'); } });

package/dist/notification-channel/index.d.ts

@@ -0,0 +1,235 @@
+import { Construct } from 'constructs';
+import * as cdktf from 'cdktf';
+export interface NotificationChannelConfig extends cdktf.TerraformMetaArguments {
+    /**
+    * The notification channel's definition
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel#definition NotificationChannel#definition}
+    */
+    readonly definition: NotificationChannelDefinition;
+    /**
+    * The entity ID the notification channel is scoped to
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel#entity_id NotificationChannel#entity_id}
+    */
+    readonly entityId: string;
+    /**
+    * The type of entity the notification channel is scoped to (e.g., 'DEPLOYMENT')
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel#entity_type NotificationChannel#entity_type}
+    */
+    readonly entityType: string;
+    /**
+    * When entity type is scoped to ORGANIZATION or WORKSPACE, this determines if child entities can access this notification channel.
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel#is_shared NotificationChannel#is_shared}
+    */
+    readonly isShared?: boolean | cdktf.IResolvable;
+    /**
+    * The notification channel's name
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel#name NotificationChannel#name}
+    */
+    readonly name: string;
+    /**
+    * The notification channel's type
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel#type NotificationChannel#type}
+    */
+    readonly type: string;
+}
+export interface NotificationChannelCreatedBy {
+}
+export declare function notificationChannelCreatedByToTerraform(struct?: NotificationChannelCreatedBy): any;
+export declare function notificationChannelCreatedByToHclTerraform(struct?: NotificationChannelCreatedBy): any;
+export declare class NotificationChannelCreatedByOutputReference extends cdktf.ComplexObject {
+    private isEmptyObject;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    */
+    constructor(terraformResource: cdktf.IInterpolatingParent, terraformAttribute: string);
+    get internalValue(): NotificationChannelCreatedBy | undefined;
+    set internalValue(value: NotificationChannelCreatedBy | undefined);
+    get apiTokenName(): any;
+    get avatarUrl(): any;
+    get fullName(): any;
+    get id(): any;
+    get subjectType(): any;
+    get username(): any;
+}
+export interface NotificationChannelDefinition {
+    /**
+    * The API key for the notification channel
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel#api_key NotificationChannel#api_key}
+    */
+    readonly apiKey?: string;
+    /**
+    * The DAG ID for the notification channel
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel#dag_id NotificationChannel#dag_id}
+    */
+    readonly dagId?: string;
+    /**
+    * The deployment API token for the notification channel
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel#deployment_api_token NotificationChannel#deployment_api_token}
+    */
+    readonly deploymentApiToken?: string;
+    /**
+    * The deployment ID for the notification channel
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel#deployment_id NotificationChannel#deployment_id}
+    */
+    readonly deploymentId?: string;
+    /**
+    * The integration key for the notification channel
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel#integration_key NotificationChannel#integration_key}
+    */
+    readonly integrationKey?: string;
+    /**
+    * The recipients for the notification channel
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel#recipients NotificationChannel#recipients}
+    */
+    readonly recipients?: string[];
+    /**
+    * The webhook URL for the notification channel
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel#webhook_url NotificationChannel#webhook_url}
+    */
+    readonly webhookUrl?: string;
+}
+export declare function notificationChannelDefinitionToTerraform(struct?: NotificationChannelDefinition | cdktf.IResolvable): any;
+export declare function notificationChannelDefinitionToHclTerraform(struct?: NotificationChannelDefinition | cdktf.IResolvable): any;
+export declare class NotificationChannelDefinitionOutputReference extends cdktf.ComplexObject {
+    private isEmptyObject;
+    private resolvableValue?;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    */
+    constructor(terraformResource: cdktf.IInterpolatingParent, terraformAttribute: string);
+    get internalValue(): NotificationChannelDefinition | cdktf.IResolvable | undefined;
+    set internalValue(value: NotificationChannelDefinition | cdktf.IResolvable | undefined);
+    private _apiKey?;
+    get apiKey(): string;
+    set apiKey(value: string);
+    resetApiKey(): void;
+    get apiKeyInput(): string;
+    private _dagId?;
+    get dagId(): string;
+    set dagId(value: string);
+    resetDagId(): void;
+    get dagIdInput(): string;
+    private _deploymentApiToken?;
+    get deploymentApiToken(): string;
+    set deploymentApiToken(value: string);
+    resetDeploymentApiToken(): void;
+    get deploymentApiTokenInput(): string;
+    private _deploymentId?;
+    get deploymentId(): string;
+    set deploymentId(value: string);
+    resetDeploymentId(): void;
+    get deploymentIdInput(): string;
+    private _integrationKey?;
+    get integrationKey(): string;
+    set integrationKey(value: string);
+    resetIntegrationKey(): void;
+    get integrationKeyInput(): string;
+    private _recipients?;
+    get recipients(): string[];
+    set recipients(value: string[]);
+    resetRecipients(): void;
+    get recipientsInput(): string[];
+    private _webhookUrl?;
+    get webhookUrl(): string;
+    set webhookUrl(value: string);
+    resetWebhookUrl(): void;
+    get webhookUrlInput(): string;
+}
+export interface NotificationChannelUpdatedBy {
+}
+export declare function notificationChannelUpdatedByToTerraform(struct?: NotificationChannelUpdatedBy): any;
+export declare function notificationChannelUpdatedByToHclTerraform(struct?: NotificationChannelUpdatedBy): any;
+export declare class NotificationChannelUpdatedByOutputReference extends cdktf.ComplexObject {
+    private isEmptyObject;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    */
+    constructor(terraformResource: cdktf.IInterpolatingParent, terraformAttribute: string);
+    get internalValue(): NotificationChannelUpdatedBy | undefined;
+    set internalValue(value: NotificationChannelUpdatedBy | undefined);
+    get apiTokenName(): any;
+    get avatarUrl(): any;
+    get fullName(): any;
+    get id(): any;
+    get subjectType(): any;
+    get username(): any;
+}
+/**
+* Represents a {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel astro_notification_channel}
+*/
+export declare class NotificationChannel extends cdktf.TerraformResource {
+    static readonly tfResourceType = "astro_notification_channel";
+    /**
+    * Generates CDKTF code for importing a NotificationChannel resource upon running "cdktf plan <stack-name>"
+    * @param scope The scope in which to define this construct
+    * @param importToId The construct id used in the generated config for the NotificationChannel to import
+    * @param importFromId The id of the existing NotificationChannel that should be imported. Refer to the {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel#import import section} in the documentation of this resource for the id to use
+    * @param provider? Optional instance of the provider where the NotificationChannel to import is found
+    */
+    static generateConfigForImport(scope: Construct, importToId: string, importFromId: string, provider?: cdktf.TerraformProvider): any;
+    /**
+    * Create a new {@link https://registry.terraform.io/providers/astronomer/astro/1.0.8/docs/resources/notification_channel astro_notification_channel} Resource
+    *
+    * @param scope The scope in which to define this construct
+    * @param id The scoped construct ID. Must be unique amongst siblings in the same scope
+    * @param options NotificationChannelConfig
+    */
+    constructor(scope: Construct, id: string, config: NotificationChannelConfig);
+    get createdAt(): any;
+    private _createdBy;
+    get createdBy(): NotificationChannelCreatedByOutputReference;
+    private _definition;
+    get definition(): NotificationChannelDefinitionOutputReference;
+    putDefinition(value: NotificationChannelDefinition): void;
+    get definitionInput(): any;
+    get deploymentId(): any;
+    private _entityId?;
+    get entityId(): string;
+    set entityId(value: string);
+    get entityIdInput(): string;
+    get entityName(): any;
+    private _entityType?;
+    get entityType(): string;
+    set entityType(value: string);
+    get entityTypeInput(): string;
+    get id(): any;
+    private _isShared?;
+    get isShared(): boolean | cdktf.IResolvable;
+    set isShared(value: boolean | cdktf.IResolvable);
+    resetIsShared(): void;
+    get isSharedInput(): any;
+    private _name?;
+    get name(): string;
+    set name(value: string);
+    get nameInput(): string;
+    private _type?;
+    get type(): string;
+    set type(value: string);
+    get typeInput(): string;
+    get updatedAt(): any;
+    private _updatedBy;
+    get updatedBy(): NotificationChannelUpdatedByOutputReference;
+    get workspaceId(): any;
+    protected synthesizeAttributes(): {
+        [name: string]: any;
+    };
+    protected synthesizeHclAttributes(): {
+        [name: string]: any;
+    };
+}