/**
 * A decimal type describing a decimal with any precision/scale.
 */
interface AnyDecimalType {
}
interface AnyStructType$1 {
}
interface AnyType {
}
interface ArrayLiteral {
    values: Array<LiteralParameter>;
}
interface ArrayType {
    elementType: DataType$2;
}
interface ArrayV2Type {
    elementType: ExplicitType;
}
interface BinaryLiteral {
    value: string;
}
interface BinaryType$1 {
}
interface BooleanLiteral {
    value: boolean;
}
interface BooleanType$2 {
}
interface ByteType$1 {
}
/**
 * This literal will be used as a column name and must match rules for column names.
 */
interface ColumnNameLiteralConstraint {
}
/**
 * Definition type: ColumnPairParameterType
 */
interface ColumnPairParameter {
    left: ColumnReferenceParameter;
    right: ColumnReferenceParameter;
}
interface ColumnReferenceParameter {
    columnName: string;
}
/**
 * Parameter that represents column reference of a given type.
 * Instance type: ColumnReferenceParameter
 */
interface ColumnReferenceParameterType {
    origin?: ParameterId | null | undefined;
    requiredType: TypeReference;
}
interface CompositeInputParameterType_list {
    type: "list";
    list: ListParameterType;
}
interface CompositeInputParameterType_set {
    type: "set";
    set: SetParameterType;
}
/**
 * Instance type: CompositeParameter
 */
type CompositeInputParameterType = CompositeInputParameterType_list | CompositeInputParameterType_set;
interface CompositeParameter_list {
    type: "list";
    list: ListParameter;
}
interface CompositeParameter_set {
    type: "set";
    set: SetParameter;
}
/**
 * Definition type: CompositeInputParameterType
 */
type CompositeParameter = CompositeParameter_list | CompositeParameter_set;
/**
 * Unions collections together to a list
 */
interface ConcatAdapter {
    collections: Array<Parameter>;
}
interface DatasetParameter {
    rid: string;
}
interface DataType_array {
    type: "array";
    array: ArrayType;
}
interface DataType_arrayV2 {
    type: "arrayV2";
    arrayV2: ArrayV2Type;
}
interface DataType_binary$1 {
    type: "binary";
    binary: BinaryType$1;
}
interface DataType_boolean$1 {
    type: "boolean";
    boolean: BooleanType$2;
}
interface DataType_byte$1 {
    type: "byte";
    byte: ByteType$1;
}
interface DataType_date$1 {
    type: "date";
    date: DateType$2;
}
interface DataType_decimal$1 {
    type: "decimal";
    decimal: DecimalType$2;
}
interface DataType_double$1 {
    type: "double";
    double: DoubleType$2;
}
interface DataType_float$1 {
    type: "float";
    float: FloatType$1;
}
interface DataType_integer$1 {
    type: "integer";
    integer: IntegerType$2;
}
interface DataType_long$1 {
    type: "long";
    long: LongType$2;
}
interface DataType_map$1 {
    type: "map";
    map: MapType$1;
}
interface DataType_mapV2 {
    type: "mapV2";
    mapV2: MapV2Type;
}
interface DataType_short$1 {
    type: "short";
    short: ShortType$1;
}
interface DataType_string$1 {
    type: "string";
    string: StringType$2;
}
interface DataType_struct {
    type: "struct";
    struct: StructType$1;
}
interface DataType_structV2 {
    type: "structV2";
    structV2: StructV2Type;
}
interface DataType_timestamp$1 {
    type: "timestamp";
    timestamp: TimestampType$2;
}
interface DataType_any {
    type: "any";
    any: AnyType;
}
interface DataType_anyDecimal {
    type: "anyDecimal";
    anyDecimal: AnyDecimalType;
}
interface DataType_anyStruct {
    type: "anyStruct";
    anyStruct: AnyStructType$1;
}
type DataType$2 = DataType_array | DataType_arrayV2 | DataType_binary$1 | DataType_boolean$1 | DataType_byte$1 | DataType_date$1 | DataType_decimal$1 | DataType_double$1 | DataType_float$1 | DataType_integer$1 | DataType_long$1 | DataType_map$1 | DataType_mapV2 | DataType_short$1 | DataType_string$1 | DataType_struct | DataType_structV2 | DataType_timestamp$1 | DataType_any | DataType_anyDecimal | DataType_anyStruct;
interface DateLiteral {
    value: string;
}
interface DatetimeLiteral {
    value: string;
}
interface DateType$2 {
}
/**
 * Value stored in string to preserve exact scale and value
 */
interface DecimalLiteral {
    value: string;
}
interface DecimalType$2 {
    precision: number;
    scale: number;
}
interface DeduplicateListAdapter {
    list: Parameter;
}
type Direction = "ASCENDING" | "DESCENDING";
interface DoubleLiteral {
    value: number | "NaN" | "Infinity" | "-Infinity";
}
interface DoubleType$2 {
}
type EnumId = string;
interface EnumParameter {
    value: string;
}
/**
 * Instance Type: EnumParameter
 */
interface EnumParameterType {
    id?: EnumId | null | undefined;
    values: Array<EnumValueDescription>;
}
interface EnumValueDescription {
    description?: string | null | undefined;
    displayName?: string | null | undefined;
    value: string;
}
/**
 * Set of types allowed for given expression
 */
interface ExplicitType {
    types: Array<LogicalType>;
}
/**
 * Uniquely identifying name for expression
 */
type ExpressionId = string;
/**
 * Expressions can have different behavior and this changes where they can be used.
 * Some expressions like `length(col)` operate on a row level. We call these column expressions.
 * Others like `max(col)` are aggregating and expressions like `rank(col)` can only be used in a window.
 */
type ExpressionKind = "COLUMN" | "AGGREGATE" | "WINDOW" | "GENERATOR";
interface ExpressionParameter_literal {
    type: "literal";
    literal: LiteralParameter;
}
interface ExpressionParameter_column {
    type: "column";
    column: ColumnReferenceParameter;
}
interface ExpressionParameter_columnExpression {
    type: "columnExpression";
    columnExpression: InstantiatedColumnExpression;
}
type ExpressionParameter = ExpressionParameter_literal | ExpressionParameter_column | ExpressionParameter_columnExpression;
/**
 * Parameter unifying literal, column references and column expressions.
 * Instance type: ExpressionParameter
 */
interface ExpressionParameterType {
    acceptedExpressionKinds: Array<ExpressionKind>;
    aliasNotUsed?: boolean | null | undefined;
    origin?: ParameterId | null | undefined;
    requiredOutputType: TypeReference;
}
/**
 * Parameter representing an input containing files.
 * Instance type: DatasetParameter
 */
interface FilesInputParameterType {
}
interface FloatType$1 {
}
/**
 * Describes an array of type references to allow generics
 */
interface GenericArrayType {
    elementType: TypeReference;
}
/**
 * Describes a map of type references to allow generics
 */
interface GenericMapType {
    keyType: TypeReference;
    valueType: TypeReference;
}
/**
 * Describes a struct element to allow generics
 */
interface GenericStructElementType {
    name?: string | null | undefined;
    valueType: TypeReference;
}
/**
 * Describes a struct element to allow generics
 */
interface GenericStructType {
    fields: Array<GenericStructElementType>;
}
interface GetElementAtAdapter {
    index: number;
    input: Parameter;
}
interface InputParameterType_primitive {
    type: "primitive";
    primitive: PrimitiveInputParameterType;
}
interface InputParameterType_composite {
    type: "composite";
    composite: CompositeInputParameterType;
}
/**
 * Instance type: Parameter
 */
type InputParameterType = InputParameterType_primitive | InputParameterType_composite;
/**
 * Definition type: ColumnExpression
 */
interface InstantiatedColumnExpression {
    arguments: Record<ParameterId, Parameter>;
    displayName?: string | null | undefined;
    expressionId: ExpressionId;
    expressionVersion: Version;
    id: InstantiatedExpressionId;
}
type InstantiatedExpressionId = string;
type InstantiatedTransformId = string;
/**
 * Definition type: Window
 */
interface InstantiatedWindow {
    arguments: Record<ParameterId, Parameter>;
    displayName?: string | null | undefined;
    id: InstantiatedWindowId;
    windowId: WindowId;
    windowVersion: Version;
}
type InstantiatedWindowId = string;
interface InstantiateTupleAdapter {
    left: Parameter;
    right: Parameter;
}
interface IntegerLiteral {
    value: number;
}
interface IntegerType$2 {
}
type JoinTypeParameter = "INNER" | "LEFT_OUTER" | "FULL_OUTER" | "RIGHT_OUTER" | "SEMI" | "ANTI";
/**
 * Definition type: ListParameterType
 */
interface ListParameter {
    elements: Array<PrimitiveParameter>;
}
/**
 * Instance type: ListParameter
 */
interface ListParameterType {
    maxSize?: number | null | undefined;
    minSize?: number | null | undefined;
    subType: PrimitiveInputParameterType;
}
interface ListToSetAdapter {
    input: Parameter;
}
interface LiteralConstraint_columnName {
    type: "columnName";
    columnName: ColumnNameLiteralConstraint;
}
type LiteralConstraint = LiteralConstraint_columnName;
interface LiteralParameter_binary {
    type: "binary";
    binary: BinaryLiteral;
}
interface LiteralParameter_boolean {
    type: "boolean";
    boolean: BooleanLiteral;
}
interface LiteralParameter_datetime {
    type: "datetime";
    datetime: DatetimeLiteral;
}
interface LiteralParameter_date {
    type: "date";
    date: DateLiteral;
}
interface LiteralParameter_double {
    type: "double";
    double: DoubleLiteral;
}
interface LiteralParameter_integer {
    type: "integer";
    integer: IntegerLiteral;
}
interface LiteralParameter_long {
    type: "long";
    long: LongLiteral;
}
interface LiteralParameter_decimal {
    type: "decimal";
    decimal: DecimalLiteral;
}
interface LiteralParameter_string {
    type: "string";
    string: StringLiteral;
}
interface LiteralParameter_array {
    type: "array";
    array: ArrayLiteral;
}
interface LiteralParameter_map {
    type: "map";
    map: MapLiteral;
}
interface LiteralParameter_null {
    type: "null";
    null: NullLiteral;
}
type LiteralParameter = LiteralParameter_binary | LiteralParameter_boolean | LiteralParameter_datetime | LiteralParameter_date | LiteralParameter_double | LiteralParameter_integer | LiteralParameter_long | LiteralParameter_decimal | LiteralParameter_string | LiteralParameter_array | LiteralParameter_map | LiteralParameter_null;
/**
 * Parameter that represents literal value of a given type.
 * Instance type: LiteralParameter
 */
interface LiteralParameterType {
    additionalConstraints: Array<LiteralConstraint>;
    requiredType: TypeReference;
}
/**
 * Represents logical type with underpinning physical type that describes the storage of it
 */
interface LogicalType {
    physicalType: DataType$2;
}
interface LongLiteral {
    value: number;
}
interface LongType$2 {
}
/**
 * References a single input element of a map operation. This is the argument to the map function.
 */
interface MapElementInput {
}
/**
 * Takes a collection (list, set) and maps every element according to ParameterAdapter
 */
interface MapElementsAdapter {
    collection: Parameter;
    mapping: ParameterAdapter;
}
interface MapEntry {
    key: LiteralParameter;
    value: LiteralParameter;
}
interface MapLiteral {
    entries: Array<MapEntry>;
}
interface MapType$1 {
    keyType: DataType$2;
    valueType: DataType$2;
}
interface MapV2Type {
    keyType: ExplicitType;
    valueType: ExplicitType;
}
interface NullLiteral {
}
interface Parameter_primitive {
    type: "primitive";
    primitive: PrimitiveParameter;
}
interface Parameter_composite {
    type: "composite";
    composite: CompositeParameter;
}
interface Parameter_reference {
    type: "reference";
    reference: ParameterReference;
}
interface Parameter_adapter {
    type: "adapter";
    adapter: ParameterAdapter;
}
/**
 * Definition type: InputParameterType
 */
type Parameter = Parameter_primitive | Parameter_composite | Parameter_reference | Parameter_adapter;
interface ParameterAdapter_identity {
    type: "identity";
    identity: ParameterId;
}
interface ParameterAdapter_mapElements {
    type: "mapElements";
    mapElements: MapElementsAdapter;
}
interface ParameterAdapter_instantiateExpression {
    type: "instantiateExpression";
    instantiateExpression: InstantiatedColumnExpression;
}
interface ParameterAdapter_getElement {
    type: "getElement";
    getElement: GetElementAtAdapter;
}
interface ParameterAdapter_listToSet {
    type: "listToSet";
    listToSet: ListToSetAdapter;
}
interface ParameterAdapter_mapElementInput {
    type: "mapElementInput";
    mapElementInput: MapElementInput;
}
interface ParameterAdapter_concat {
    type: "concat";
    concat: ConcatAdapter;
}
interface ParameterAdapter_stringConcat {
    type: "stringConcat";
    stringConcat: StringConcatAdapter;
}
interface ParameterAdapter_stringToColumn {
    type: "stringToColumn";
    stringToColumn: StringToColumnAdapter;
}
interface ParameterAdapter_instantiateTuple {
    type: "instantiateTuple";
    instantiateTuple: InstantiateTupleAdapter;
}
interface ParameterAdapter_deduplicateList {
    type: "deduplicateList";
    deduplicateList: DeduplicateListAdapter;
}
type ParameterAdapter = ParameterAdapter_identity | ParameterAdapter_mapElements | ParameterAdapter_instantiateExpression | ParameterAdapter_getElement | ParameterAdapter_listToSet | ParameterAdapter_mapElementInput | ParameterAdapter_concat | ParameterAdapter_stringConcat | ParameterAdapter_stringToColumn | ParameterAdapter_instantiateTuple | ParameterAdapter_deduplicateList;
/**
 * Name of a parameter in a given function or transformation
 */
type ParameterId = string;
/**
 * Used to reference outer parameters in grouped transforms
 */
interface ParameterReference {
    parameterId: ParameterId;
}
interface PartitionedWindow {
    partitionBy: Array<string>;
    sortBy?: SortParameter | null | undefined;
}
interface PreviewOutputParameter {
    outputParameterId: ParameterId;
}
interface PrimitiveInputParameterType_literal {
    type: "literal";
    literal: LiteralParameterType;
}
interface PrimitiveInputParameterType_tabular {
    type: "tabular";
    tabular: TabularInputParameterType;
}
interface PrimitiveInputParameterType_files {
    type: "files";
    files: FilesInputParameterType;
}
interface PrimitiveInputParameterType_column {
    type: "column";
    column: ColumnReferenceParameterType;
}
interface PrimitiveInputParameterType_expression {
    type: "expression";
    expression: ExpressionParameterType;
}
interface PrimitiveInputParameterType_window {
    type: "window";
    window: WindowParameterType;
}
interface PrimitiveInputParameterType_windowV2 {
    type: "windowV2";
    windowV2: WindowParameterTypeV2;
}
interface PrimitiveInputParameterType_sorting {
    type: "sorting";
    sorting: SortParameterType;
}
interface PrimitiveInputParameterType_enum {
    type: "enum";
    enum: EnumParameterType;
}
interface PrimitiveInputParameterType_regex {
    type: "regex";
    regex: RegexParameterType;
}
interface PrimitiveInputParameterType_structLocator {
    type: "structLocator";
    structLocator: StructLocatorParameterType;
}
interface PrimitiveInputParameterType_timeZone {
    type: "timeZone";
    timeZone: TimeZoneParameterType;
}
interface PrimitiveInputParameterType_tuple {
    type: "tuple";
    tuple: TupleParameterType;
}
interface PrimitiveInputParameterType_typeParam {
    type: "typeParam";
    typeParam: TypeParameterType;
}
interface PrimitiveInputParameterType_rid {
    type: "rid";
    rid: ResourceIdentifierParameterType;
}
/**
 * Instance type: PrimitiveParameter
 */
type PrimitiveInputParameterType = PrimitiveInputParameterType_literal | PrimitiveInputParameterType_tabular | PrimitiveInputParameterType_files | PrimitiveInputParameterType_column | PrimitiveInputParameterType_expression | PrimitiveInputParameterType_window | PrimitiveInputParameterType_windowV2 | PrimitiveInputParameterType_sorting | PrimitiveInputParameterType_enum | PrimitiveInputParameterType_regex | PrimitiveInputParameterType_structLocator | PrimitiveInputParameterType_timeZone | PrimitiveInputParameterType_tuple | PrimitiveInputParameterType_typeParam | PrimitiveInputParameterType_rid;
interface PrimitiveParameter_column {
    type: "column";
    column: ColumnReferenceParameter;
}
interface PrimitiveParameter_columnExpression {
    type: "columnExpression";
    columnExpression: InstantiatedColumnExpression;
}
interface PrimitiveParameter_columnPair {
    type: "columnPair";
    columnPair: ColumnPairParameter;
}
interface PrimitiveParameter_dataset {
    type: "dataset";
    dataset: DatasetParameter;
}
interface PrimitiveParameter_expression {
    type: "expression";
    expression: ExpressionParameter;
}
interface PrimitiveParameter_joinType {
    type: "joinType";
    joinType: JoinTypeParameter;
}
interface PrimitiveParameter_transformOutput {
    type: "transformOutput";
    transformOutput: TransformOutputReference;
}
interface PrimitiveParameter_window {
    type: "window";
    window: WindowParameter;
}
interface PrimitiveParameter_windowV2 {
    type: "windowV2";
    windowV2: InstantiatedWindow;
}
interface PrimitiveParameter_literal {
    type: "literal";
    literal: LiteralParameter;
}
interface PrimitiveParameter_enum {
    type: "enum";
    enum: EnumParameter;
}
interface PrimitiveParameter_sort {
    type: "sort";
    sort: SortParameter;
}
interface PrimitiveParameter_regex {
    type: "regex";
    regex: RegexParameter;
}
interface PrimitiveParameter_previewOutput {
    type: "previewOutput";
    previewOutput: PreviewOutputParameter;
}
interface PrimitiveParameter_timeZone {
    type: "timeZone";
    timeZone: TimeZoneParameter;
}
interface PrimitiveParameter_tuple {
    type: "tuple";
    tuple: TupleParameter;
}
interface PrimitiveParameter_typeParam {
    type: "typeParam";
    typeParam: TypeParameter;
}
interface PrimitiveParameter_rid {
    type: "rid";
    rid: ResourceIdentifierParameter;
}
interface PrimitiveParameter_reference {
    type: "reference";
    reference: ParameterReference;
}
interface PrimitiveParameter_structLocator {
    type: "structLocator";
    structLocator: StructLocatorParameter;
}
/**
 * Definition type: PrimitiveInputParameterType
 */
type PrimitiveParameter = PrimitiveParameter_column | PrimitiveParameter_columnExpression | PrimitiveParameter_columnPair | PrimitiveParameter_dataset | PrimitiveParameter_expression | PrimitiveParameter_joinType | PrimitiveParameter_transformOutput | PrimitiveParameter_window | PrimitiveParameter_windowV2 | PrimitiveParameter_literal | PrimitiveParameter_enum | PrimitiveParameter_sort | PrimitiveParameter_regex | PrimitiveParameter_previewOutput | PrimitiveParameter_timeZone | PrimitiveParameter_tuple | PrimitiveParameter_typeParam | PrimitiveParameter_rid | PrimitiveParameter_reference | PrimitiveParameter_structLocator;
interface RegexParameter {
    pattern: string;
}
/**
 * Instance type: RegexParameter
 */
interface RegexParameterType {
}
interface ResourceIdentifierParameter {
    rid: string;
}
/**
 * Instance type: ResourceIdentifierParameter
 */
interface ResourceIdentifierParameterType {
    allowedTypes: Array<ResourceIdentifierType>;
}
/**
 * Specifies the service and type field of a resource identifier.
 * Rid structure is ri.service.instance.type.locator.
 */
interface ResourceIdentifierType {
    service: string;
    type: string;
}
/**
 * Definition type: SetParameterType
 */
interface SetParameter {
    elements: Array<PrimitiveParameter>;
}
/**
 * Instance type: SetParameter
 */
interface SetParameterType {
    maxSize?: number | null | undefined;
    minSize?: number | null | undefined;
    subType: PrimitiveInputParameterType;
}
interface ShortType$1 {
}
interface SortColumn {
    columnName: string;
    direction: Direction;
}
interface SortParameter {
    columns: Array<SortColumn>;
}
/**
 * Instance type: SortParameter
 */
interface SortParameterType {
    origin?: ParameterId | null | undefined;
}
/**
 * Concats a set of strings together, outputs StringLiteral
 */
interface StringConcatAdapter {
    strings: Array<Parameter>;
}
interface StringLiteral {
    value: string;
}
/**
 * Converts StringLiteral to ColumnReferenceParameter
 */
interface StringToColumnAdapter {
    string: Parameter;
}
interface StringType$2 {
}
interface StructElement {
    name: string;
    type: DataType$2;
}
interface StructElementV2 {
    name: string;
    type: ExplicitType;
}
/**
 * Used to locate a nested field in a struct.
 */
interface StructLocatorParameter {
    locator: Array<string>;
}
/**
 * Instance type: StructLocatorParameter
 */
interface StructLocatorParameterType {
}
interface StructType$1 {
    fields: Array<StructElement>;
}
interface StructV2Type {
    fields: Array<StructElementV2>;
}
/**
 * Parameter representing tabular inputs.
 * Instance type: DatasetParameter
 */
interface TabularInputParameterType {
    isStreamable: boolean;
}
interface TimestampType$2 {
}
/**
 * Matches definition type: TimeZoneParameterType
 */
interface TimeZoneParameter {
    timeZoneId: string;
}
/**
 * Instance type: TimeZoneParameter
 *
 * This is not an enum because we don't want to maintain a list of valid time zones.
 */
interface TimeZoneParameterType {
}
/**
 * Use the output of another transform as input.
 *
 * Matches definition type: DatasetParameterType
 */
interface TransformOutputReference {
    id: InstantiatedTransformId;
    parameterId: ParameterId;
}
/**
 * Definition Type: TupleParameterType
 */
interface TupleParameter {
    left?: PrimitiveParameter | null | undefined;
    right?: PrimitiveParameter | null | undefined;
}
/**
 * Instance type: TupleParameter
 */
interface TupleParameterType {
    leftName?: string | null | undefined;
    leftType: PrimitiveInputParameterType;
    rightName?: string | null | undefined;
    rightType: PrimitiveInputParameterType;
}
interface TypeParameter {
    type: DataType$2;
}
/**
 * Parameter representing type variable that the expression or transformation uses
 */
interface TypeParameterType {
    requiredType: TypeReference;
}
interface TypeReference_variable {
    type: "variable";
    variable: TypeVariableReference;
}
interface TypeReference_explicit {
    type: "explicit";
    explicit: ExplicitType;
}
interface TypeReference_array {
    type: "array";
    array: GenericArrayType;
}
interface TypeReference_map {
    type: "map";
    map: GenericMapType;
}
interface TypeReference_struct {
    type: "struct";
    struct: GenericStructType;
}
type TypeReference = TypeReference_variable | TypeReference_explicit | TypeReference_array | TypeReference_map | TypeReference_struct;
/**
 * Reference to a type variable defined within the operation scope
 */
type TypeVariableReference = string;
interface Version {
    major: number;
}
/**
 * Uniquely identifying name for window
 */
type WindowId = string;
interface WindowParameter_partitioned {
    type: "partitioned";
    partitioned: PartitionedWindow;
}
/**
 * DEPRECATED - InstantiatedWindow
 */
type WindowParameter = WindowParameter_partitioned;
/**
 * Parameter representing a window
 * Instance type: WindowParameter
 */
interface WindowParameterType {
}
/**
 * Parameter representing a window
 * Instance type: InstantiatedWindow
 */
interface WindowParameterTypeV2 {
    origin?: ParameterId | null | undefined;
}

/**
 * Used to propagate generic errors that are aggregated in endpoint responses, rather than thrown in a
 * synchronous response. Can be used to convert Conjure `ServiceException` and `RemoteException` types.
 * Should only be constructed using the `com.palantir.marketplace.utils.Exceptions.toSerializableError` helper
 * class.
 * Similar to `com.palantir.conjure.java.api.errors.SerializableError`, however whilst `SerializableError` always
 * uses Objects.toString() parameter serialization, this type also supports JSON parameter serialization and
 * annotates the serialization format.
 */
interface MarketplaceSerializableError {
    areParametersV2JsonSerialized?: boolean | null | undefined;
    errorCode: string;
    errorInstanceId: ErrorInstanceId;
    errorName: string;
    parameters: Record<string, string>;
    parametersV2: any;
}

/**
 * Logical AND - destination function must satisfy ALL nested expressions.
 */
interface AndExpression {
    expressions: Array<ContractExpression>;
}
interface ContractExpression_and {
    type: "and";
    and: AndExpression;
}
interface ContractExpression_or {
    type: "or";
    or: OrExpression;
}
interface ContractExpression_contract {
    type: "contract";
    contract: ContractReference;
}
/**
 * A boolean expression tree for specifying contract requirements. Parallel to ContractExpressionIdentifier,
 * but uses FunctionContractReference (BlockInternalId) for leaf nodes instead of FunctionContractIdentifier.
 */
type ContractExpression = ContractExpression_and | ContractExpression_or | ContractExpression_contract;
/**
 * Leaf node referring to a single contract that must be implemented.
 */
interface ContractReference {
    contract: FunctionContractReference;
}
/**
 * Logical OR - destination function must satisfy AT LEAST ONE nested expression.
 */
interface OrExpression {
    expressions: Array<ContractExpression>;
}

interface AnonymousCustomType {
    fields: Record<CustomTypeFieldName, DataType$1>;
}
interface AttachmentType$1 {
}
interface BinaryType {
}
interface BooleanType$1 {
}
interface BucketKeyType_double {
    type: "double";
    double: DoubleType$1;
}
interface BucketKeyType_integer {
    type: "integer";
    integer: IntegerType$1;
}
interface BucketKeyType_date {
    type: "date";
    date: DateType$1;
}
interface BucketKeyType_timestamp {
    type: "timestamp";
    timestamp: TimestampType$1;
}
interface BucketKeyType_range {
    type: "range";
    range: RangeType;
}
interface BucketKeyType_string {
    type: "string";
    string: StringType$1;
}
interface BucketKeyType_boolean {
    type: "boolean";
    boolean: BooleanType$1;
}
type BucketKeyType = BucketKeyType_double | BucketKeyType_integer | BucketKeyType_date | BucketKeyType_timestamp | BucketKeyType_range | BucketKeyType_string | BucketKeyType_boolean;
interface BucketValueType_double {
    type: "double";
    double: DoubleType$1;
}
interface BucketValueType_timestamp {
    type: "timestamp";
    timestamp: TimestampType$1;
}
interface BucketValueType_date {
    type: "date";
    date: DateType$1;
}
type BucketValueType = BucketValueType_double | BucketValueType_timestamp | BucketValueType_date;
interface ByteType {
}
interface ClassificationMarkingType {
}
interface CustomType {
    about?: LocalizedTitleAndDescription | null | undefined;
    fields: Record<CustomTypeFieldName, DataType$1>;
    id: CustomTypeId;
}
type CustomTypeFieldName = string;
type CustomTypeId = string;
interface DataType_boolean {
    type: "boolean";
    boolean: BooleanType$1;
}
interface DataType_integer {
    type: "integer";
    integer: IntegerType$1;
}
interface DataType_long {
    type: "long";
    long: LongType$1;
}
interface DataType_float {
    type: "float";
    float: FloatType;
}
interface DataType_double {
    type: "double";
    double: DoubleType$1;
}
interface DataType_decimal {
    type: "decimal";
    decimal: DecimalType$1;
}
interface DataType_string {
    type: "string";
    string: StringType$1;
}
interface DataType_date {
    type: "date";
    date: DateType$1;
}
interface DataType_timestamp {
    type: "timestamp";
    timestamp: TimestampType$1;
}
interface DataType_attachment {
    type: "attachment";
    attachment: AttachmentType$1;
}
interface DataType_mediaReference {
    type: "mediaReference";
    mediaReference: MediaReferenceType$1;
}
interface DataType_list {
    type: "list";
    list: ListType;
}
interface DataType_logical {
    type: "logical";
    logical: Void;
}
interface DataType_logicalV2 {
    type: "logicalV2";
    logicalV2: LogicalTypeReference;
}
interface DataType_set {
    type: "set";
    set: SetType;
}
interface DataType_map {
    type: "map";
    map: MapType;
}
interface DataType_object {
    type: "object";
    object: ObjectType;
}
interface DataType_objectSet {
    type: "objectSet";
    objectSet: ObjectSetType;
}
interface DataType_interface {
    type: "interface";
    interface: InterfaceType;
}
interface DataType_interfaceObjectSet {
    type: "interfaceObjectSet";
    interfaceObjectSet: InterfaceObjectSetType;
}
interface DataType_ontologyEdit {
    type: "ontologyEdit";
    ontologyEdit: OntologyEditType;
}
interface DataType_range {
    type: "range";
    range: RangeType;
}
interface DataType_functionCustomType {
    type: "functionCustomType";
    functionCustomType: CustomTypeId;
}
interface DataType_optionalType {
    type: "optionalType";
    optionalType: OptionalType;
}
interface DataType_anonymousCustomType {
    type: "anonymousCustomType";
    anonymousCustomType: AnonymousCustomType;
}
interface DataType_twoDimensionalAggregation {
    type: "twoDimensionalAggregation";
    twoDimensionalAggregation: TwoDimensionalAggregationType;
}
interface DataType_threeDimensionalAggregation {
    type: "threeDimensionalAggregation";
    threeDimensionalAggregation: ThreeDimensionalAggregationType;
}
interface DataType_principal {
    type: "principal";
    principal: PrincipalType$1;
}
interface DataType_user {
    type: "user";
    user: UserType;
}
interface DataType_group {
    type: "group";
    group: GroupType;
}
interface DataType_notification {
    type: "notification";
    notification: NotificationType$1;
}
interface DataType_modelGraph {
    type: "modelGraph";
    modelGraph: ModelGraphType;
}
interface DataType_timeSeries {
    type: "timeSeries";
    timeSeries: TimeSeriesType;
}
interface DataType_geoShape {
    type: "geoShape";
    geoShape: GeoShapeType;
}
interface DataType_marking {
    type: "marking";
    marking: MarkingType$1;
}
interface DataType_binary {
    type: "binary";
    binary: BinaryType;
}
interface DataType_byte {
    type: "byte";
    byte: ByteType;
}
interface DataType_short {
    type: "short";
    short: ShortType;
}
interface DataType_vector {
    type: "vector";
    vector: VectorType;
}
interface DataType_typeReference {
    type: "typeReference";
    typeReference: TypeIdentifier;
}
interface DataType_union {
    type: "union";
    union: UnionType;
}
/**
 * All types supported by the Function Registry.
 */
type DataType$1 = DataType_boolean | DataType_integer | DataType_long | DataType_float | DataType_double | DataType_decimal | DataType_string | DataType_date | DataType_timestamp | DataType_attachment | DataType_mediaReference | DataType_list | DataType_logical | DataType_logicalV2 | DataType_set | DataType_map | DataType_object | DataType_objectSet | DataType_interface | DataType_interfaceObjectSet | DataType_ontologyEdit | DataType_range | DataType_functionCustomType | DataType_optionalType | DataType_anonymousCustomType | DataType_twoDimensionalAggregation | DataType_threeDimensionalAggregation | DataType_principal | DataType_user | DataType_group | DataType_notification | DataType_modelGraph | DataType_timeSeries | DataType_geoShape | DataType_marking | DataType_binary | DataType_byte | DataType_short | DataType_vector | DataType_typeReference | DataType_union;
interface DateType$1 {
}
interface DecimalType$1 {
}
interface DoubleType$1 {
}
/**
 * This indicates an enum time series definition.
 */
interface EnumTimeSeriesType {
}
interface FloatType {
}
/**
 * An array of GeoShape types that may contain shapes of any kind.
 */
interface GeometryCollectionType {
}
/**
 * Represents a single geographic point.
 */
interface GeoPointType {
}
interface GeoShapeSubType_geoPoint {
    type: "geoPoint";
    geoPoint: GeoPointType;
}
interface GeoShapeSubType_polygon {
    type: "polygon";
    polygon: PolygonType;
}
interface GeoShapeSubType_lineString {
    type: "lineString";
    lineString: LineStringType;
}
interface GeoShapeSubType_multiGeoPoint {
    type: "multiGeoPoint";
    multiGeoPoint: MultiGeoPointType;
}
interface GeoShapeSubType_multiPolygon {
    type: "multiPolygon";
    multiPolygon: MultiPolygonType;
}
interface GeoShapeSubType_multiLineString {
    type: "multiLineString";
    multiLineString: MultiLineStringType;
}
interface GeoShapeSubType_geometryCollection {
    type: "geometryCollection";
    geometryCollection: GeometryCollectionType;
}
type GeoShapeSubType = GeoShapeSubType_geoPoint | GeoShapeSubType_polygon | GeoShapeSubType_lineString | GeoShapeSubType_multiGeoPoint | GeoShapeSubType_multiPolygon | GeoShapeSubType_multiLineString | GeoShapeSubType_geometryCollection;
/**
 * Represents a Foundry GeoShape object
 */
interface GeoShapeType {
    subType?: GeoShapeSubType | null | undefined;
}
/**
 * Represents a multipass group object.
 */
interface GroupType {
}
interface IntegerType$1 {
}
interface InterfaceObjectSetType {
    interfaceTypeReference: InterfaceTypeReference;
}
interface InterfaceType {
    interfaceTypeReference: InterfaceTypeReference;
}
/**
 * Represents a line made of two or more points.
 */
interface LineStringType {
}
interface ListType {
    elementsType: DataType$1;
}
interface LogicalTypeReference_ontologyTypeRegistryReference {
    type: "ontologyTypeRegistryReference";
    ontologyTypeRegistryReference: ValueTypeReference;
}
type LogicalTypeReference = LogicalTypeReference_ontologyTypeRegistryReference;
interface LongType$1 {
}
interface MandatoryMarkingType {
}
interface MapType {
    keysType: DataType$1;
    valuesType: DataType$1;
}
interface MarkingSubType_classificationMarking {
    type: "classificationMarking";
    classificationMarking: ClassificationMarkingType;
}
interface MarkingSubType_mandatoryMarking {
    type: "mandatoryMarking";
    mandatoryMarking: MandatoryMarkingType;
}
type MarkingSubType = MarkingSubType_classificationMarking | MarkingSubType_mandatoryMarking;
interface MarkingType$1 {
    subType: MarkingSubType;
}
interface MediaReferenceType$1 {
}
interface ModelGraphType {
}
/**
 * An array of unconnected, but likely related points.
 */
interface MultiGeoPointType {
}
/**
 * An array of linestrings.
 */
interface MultiLineStringType {
}
/**
 * An array of polygons.
 */
interface MultiPolygonType {
}
interface NestedBucketType {
    keyType: BucketKeyType;
    subBucketType: SingleBucketType;
}
/**
 * Represents a Foundry notification
 */
interface NotificationType$1 {
}
/**
 * This indicates a numeric time series definition.
 */
interface NumericTimeSeriesType {
}
interface ObjectSetType {
    objectTypeId: ObjectTypeReference;
}
interface ObjectType {
    objectTypeId: ObjectTypeReference;
}
interface OntologyEditType {
}
interface OptionalType {
    wrappedType: DataType$1;
}
/**
 * Represents a an arbitrary n sided polygon with n+1 GeoPoints.
 */
interface PolygonType {
}
/**
 * Represents a multipass principal object.
 */
interface PrincipalType$1 {
}
interface RangeType_integer {
    type: "integer";
    integer: IntegerType$1;
}
interface RangeType_double {
    type: "double";
    double: DoubleType$1;
}
interface RangeType_timestamp {
    type: "timestamp";
    timestamp: TimestampType$1;
}
interface RangeType_date {
    type: "date";
    date: DateType$1;
}
type RangeType = RangeType_integer | RangeType_double | RangeType_timestamp | RangeType_date;
interface SetType {
    elementsType: DataType$1;
}
interface ShortType {
}
interface SingleBucketType {
    keyType: BucketKeyType;
    valueType: BucketValueType;
}
interface StringType$1 {
}
interface ThreeDimensionalAggregationType {
    nestedBucketType: NestedBucketType;
}
interface TimeSeriesType {
    valueType: TimeSeriesValueType;
}
interface TimeSeriesValueType_numeric {
    type: "numeric";
    numeric: NumericTimeSeriesType;
}
interface TimeSeriesValueType_enum {
    type: "enum";
    enum: EnumTimeSeriesType;
}
type TimeSeriesValueType = TimeSeriesValueType_numeric | TimeSeriesValueType_enum;
interface TimestampType$1 {
}
interface TwoDimensionalAggregationType {
    bucketType: SingleBucketType;
}
/**
 * The safe-loggable unique identifier for a type reference.
 */
type TypeIdentifier = string;
/**
 * A type which permits any type from a list of allowed types.
 */
interface UnionType {
    allowedTypes: Array<DataType$1>;
}
/**
 * Represents a multipass user object.
 */
interface UserType {
}
interface VectorElementType_double {
    type: "double";
    double: DoubleType$1;
}
type VectorElementType = VectorElementType_double;
interface VectorType {
    dimension: number;
    elementType: VectorElementType;
}

interface AbortedStatusV3 {
    reason: BlockSetCreationAbortReason;
}
type ActionLogRuleEditedObjectRelations = Record<ObjectTypeReference, LinkTypeReference>;
type ActionLogRulePropertyValues = Record<ObjectTypePropertyReference, ActionLogValue>;
interface ActionLogRuleShape {
    actionLogObjectTypeId: ObjectTypeReference;
    editedObjectRelations: ActionLogRuleEditedObjectRelations;
    propertyValues: ActionLogRulePropertyValues;
}
interface ActionLogValue_parameterValue {
    type: "parameterValue";
    parameterValue: ActionTypeParameterReference;
}
interface ActionLogValue_objectParameterPropertyValue {
    type: "objectParameterPropertyValue";
    objectParameterPropertyValue: ObjectParameterPropertyValue;
}
interface ActionLogValue_interfaceParameterPropertyValue {
    type: "interfaceParameterPropertyValue";
    interfaceParameterPropertyValue: InterfaceParameterPropertyValue;
}
interface ActionLogValue_editedObjects {
    type: "editedObjects";
    editedObjects: ObjectTypeReference;
}
interface ActionLogValue_actionTypeRid {
    type: "actionTypeRid";
    actionTypeRid: Empty;
}
interface ActionLogValue_actionRid {
    type: "actionRid";
    actionRid: Empty;
}
interface ActionLogValue_actionTypeVersion {
    type: "actionTypeVersion";
    actionTypeVersion: Empty;
}
interface ActionLogValue_actionTimestamp {
    type: "actionTimestamp";
    actionTimestamp: Empty;
}
interface ActionLogValue_actionUser {
    type: "actionUser";
    actionUser: Empty;
}
interface ActionLogValue_isReverted {
    type: "isReverted";
    isReverted: Empty;
}
interface ActionLogValue_revertUser {
    type: "revertUser";
    revertUser: Empty;
}
interface ActionLogValue_revertTimestamp {
    type: "revertTimestamp";
    revertTimestamp: Empty;
}
interface ActionLogValue_synchronousWebhookInstanceId {
    type: "synchronousWebhookInstanceId";
    synchronousWebhookInstanceId: Empty;
}
interface ActionLogValue_asynchronousWebhookInstanceIds {
    type: "asynchronousWebhookInstanceIds";
    asynchronousWebhookInstanceIds: Empty;
}
interface ActionLogValue_notifiedUsers {
    type: "notifiedUsers";
    notifiedUsers: Empty;
}
interface ActionLogValue_notificationIds {
    type: "notificationIds";
    notificationIds: Empty;
}
interface ActionLogValue_scenarioRid {
    type: "scenarioRid";
    scenarioRid: Empty;
}
interface ActionLogValue_summary {
    type: "summary";
    summary: Array<ActionTypeRichTextComponent>;
}
type ActionLogValue = ActionLogValue_parameterValue | ActionLogValue_objectParameterPropertyValue | ActionLogValue_interfaceParameterPropertyValue | ActionLogValue_editedObjects | ActionLogValue_actionTypeRid | ActionLogValue_actionRid | ActionLogValue_actionTypeVersion | ActionLogValue_actionTimestamp | ActionLogValue_actionUser | ActionLogValue_isReverted | ActionLogValue_revertUser | ActionLogValue_revertTimestamp | ActionLogValue_synchronousWebhookInstanceId | ActionLogValue_asynchronousWebhookInstanceIds | ActionLogValue_notifiedUsers | ActionLogValue_notificationIds | ActionLogValue_scenarioRid | ActionLogValue_summary;
type ActionParameterId = string;
/**
 * The parameter referenced by the ActionParameterTypeShape was not present on the underlying ActionType.
 */
interface ActionParameterNotFound {
    actionTypeRid: ActionTypeRid;
    parameterId: ActionParameterId;
    parameterRid: ActionParameterRid;
}
type ActionParameterRid = string;
interface ActionParameterRidOrId_rid {
    type: "rid";
    rid: ActionParameterRid;
}
interface ActionParameterRidOrId_id {
    type: "id";
    id: ActionParameterId;
}
type ActionParameterRidOrId = ActionParameterRidOrId_rid | ActionParameterRidOrId_id;
type ActionParameterShapeId = string;
/**
 * The ActionParameterType references an InterfaceTypeRid for which the shape id is unresolvable. This is
 * possible when the referenced InterfaceTypeRid isn't part of the current block.
 */
interface ActionParameterShapeTypeInterfaceTypeRidUnresolvable {
    expected: BaseParameterType;
    interfaceTypeRid: InterfaceTypeRid;
}
/**
 * The ActionParameterType references an ObjectTypeId for which the shape id is unresolvable. This is
 * possible when the referenced ObjectTypeId isn't part of the current block.
 */
interface ActionParameterShapeTypeObjectTypeIdUnresolvable {
    expected: BaseParameterType;
    objectTypeId: ObjectTypeId;
}
/**
 * DEPRECATED. Use `ActionTypeParameterShape` instead.
 */
interface ActionParameterTypeShape {
    about: LocalizedTitleAndDescription;
    type: BaseParameterType;
}
/**
 * The referenced ActionParameterTypeShape was not present in the block metadata.
 */
interface ActionParameterTypeShapeNotFound {
}
/**
 * The type of the actual ActionParameterTypeShape does not match the expected type.
 */
interface ActionParameterTypeShapeTypeMismatch {
    actual: BaseParameterType;
    expected: BaseParameterType;
}
/**
 * The ActionParameterTypeShape type is of an unknown type. This indicates we might have run into a
 * new Parameter Type that isn't yet supported in Marketplace.
 */
interface ActionParameterTypeShapeTypeUnknown {
    expected: BaseParameterType;
    unknownType: string;
}
/**
 * DEPRECATED as we dont intend to provide mapping infor for action parameters v1 going forward
 */
type ActionParameterV1MappingInfo = Record<ActionParameterShapeId, BlockSetShapeId>;
type ActionTypeApiName = string;
/**
 * DEPRECATED: Replaced by block set shapes internal recommendations.
 * Recommends that an `inputShape`'s action shape is fulfilled by `fulfilledBy`'s output shape, and how to map the inner shape.
 * Note that it is possible for some input ActionParameterShapeId to not be fulfilled by the recommendation and be missing from the map.
 */
interface ActionTypeBlockSetRecommendation {
    fulfilledBy: RecommendationBlockSetReference;
    inputParameterShapesFulfilledBy: Record<ActionParameterShapeId, ActionParameterShapeId>;
    inputShape: RecommendationBlockSetReference;
}
interface ActionTypeIdentifier_ridWithoutNestedParameters {
    type: "ridWithoutNestedParameters";
    ridWithoutNestedParameters: ActionTypeRid;
}
interface ActionTypeIdentifier_rid {
    type: "rid";
    rid: ActionTypeRid;
}
interface ActionTypeIdentifier_ridWithParameters {
    type: "ridWithParameters";
    ridWithParameters: ActionTypeRidWithParameters;
}
type ActionTypeIdentifier = ActionTypeIdentifier_ridWithoutNestedParameters | ActionTypeIdentifier_rid | ActionTypeIdentifier_ridWithParameters;
interface ActionTypeLocator {
    rid: ActionTypeRid;
    version: ActionTypeVersion;
}
interface ActionTypeNotFound {
    actionTypeRid: ActionTypeRid;
}
interface ActionTypeParameterIdentifier_parameterAndAction {
    type: "parameterAndAction";
    parameterAndAction: ParameterAndAction;
}
type ActionTypeParameterIdentifier = ActionTypeParameterIdentifier_parameterAndAction;
/**
 * DEPRECATED. Use `ResolvedActionTypeParameterShape` instead.
 */
interface ActionTypeParameterIdentifiers {
    parameterId: ActionParameterId;
    parameterRid: ActionParameterRid;
}
interface ActionTypeParameterNotFound {
    actionTypeRid: ActionTypeRid;
    parameterId?: ActionParameterId | null | undefined;
    parameterRid?: ActionParameterRid | null | undefined;
}
type ActionTypeParameterReference = BlockInternalId;
interface ActionTypeParameterShape {
    about: LocalizedTitleAndDescription;
    actionType: ActionTypeReference;
    type: BaseParameterType;
}
/**
 * DEPRECATED. Use `SimpleDisplayMetadata` instead.
 */
interface ActionTypeParameterShapeDisplayMetadata {
    about: LocalizedTitleAndDescription;
}
/**
 * Recommends that an `inputShape`'s action shape is fulfilled by `fulfilledBy`'s output shape, and how to map the inner shape.
 * Note that it is possible for some input ActionParameterShapeId to not be fulfilled by the recommendation and be missing from the map.
 */
interface ActionTypeRecommendation {
    fulfilledBy: RecommendationBlockReference;
    inputParameterShapesFulfilledBy: Record<ActionParameterShapeId, ActionParameterShapeId>;
    inputShape: RecommendationBlockReference;
}
type ActionTypeReference = BlockInternalId;
/**
 * An ActionTypeRid was referenced for which the shape id could not be resolved. This is typical if the
 * referenced ObjectType has not been included as an input/output in the block.
 */
interface ActionTypeReferenceUnresolvable {
    actual: ActionTypeRid;
    expected: ActionTypeReference;
}
interface ActionTypeRichTextComponent_message {
    type: "message";
    message: Empty;
}
interface ActionTypeRichTextComponent_parameter {
    type: "parameter";
    parameter: ActionTypeParameterReference;
}
interface ActionTypeRichTextComponent_parameterProperty {
    type: "parameterProperty";
    parameterProperty: ObjectParameterPropertyValue;
}
/**
 * Generic type that can used to define a string that should have Action execution details injected into it when
 * it is rendered.
 */
type ActionTypeRichTextComponent = ActionTypeRichTextComponent_message | ActionTypeRichTextComponent_parameter | ActionTypeRichTextComponent_parameterProperty;
type ActionTypeRid = string;
/**
 * DEPRECATED. Use the separate `ActionTypeParameterIdentifier` type instead.
 */
interface ActionTypeRidWithParameters {
    parameterMapping: Record<ActionParameterShapeId, ActionParameterRidOrId>;
    rid: ActionTypeRid;
}
interface ActionTypeShape {
    about: LocalizedTitleAndDescription;
    actionLogRule?: ActionLogRuleShape | null | undefined;
    parameters: Record<ActionParameterShapeId, ActionParameterTypeShape>;
    parametersV2: Array<ActionTypeParameterReference>;
}
interface ActionTypeShapeDisplayMetadata {
    about: LocalizedTitleAndDescription;
    parameters: Record<ActionParameterShapeId, ActionTypeParameterShapeDisplayMetadata>;
}
type ActionTypeVersion = string;
/**
 * Same as `InputShapeResult`, but without an internal shape ID.
 */
interface AdditionalInputShapeResult {
    blockShapeId: BlockShapeId;
    metadata: InputShapeMetadata;
    resolvedShape: ResolvedInputShape;
    shape: InputShape;
}
/**
 * Same as `OutputShapeResult`, but without an internal shape ID.
 */
interface AdditionalOutputShapeResult {
    blockShapeId: BlockShapeId;
    resolvedShape: ResolvedOutputShape;
    shape: OutputShape;
}
interface AddToDraftGroupRequest {
    versionIds: Array<BlockSetVersionId>;
}
interface AipAgentCreateBlockRequest {
    agentRid: AipAgentRid;
    agentVersion?: AipAgentVersion | null | undefined;
}
interface AipAgentIdentifier_ridAndVersion {
    type: "ridAndVersion";
    ridAndVersion: AipAgentRidAndVersion;
}
type AipAgentIdentifier = AipAgentIdentifier_ridAndVersion;
type AipAgentMajorVersion = number;
type AipAgentMinorVersion = number;
type AipAgentRid = string;
interface AipAgentRidAndVersion {
    agentRid: AipAgentRid;
    agentVersion?: AipAgentVersion | null | undefined;
}
interface AipAgentShape {
    about: LocalizedTitleAndDescription;
}
interface AipAgentVersion {
    major: AipAgentMajorVersion;
    minor: AipAgentMinorVersion;
}
interface AllowedObjectPropertyType_objectPropertyType {
    type: "objectPropertyType";
    objectPropertyType: ObjectPropertyType;
}
/**
 * Wrapper which refers to an property type and could support set of allowed types or more flexible constraints
 */
type AllowedObjectPropertyType = AllowedObjectPropertyType_objectPropertyType;
/**
 * Profile name must be one of the specified names
 */
interface AllowedProfileNamesConstraint {
    names: Array<SparkProfileName>;
}
/**
 * This shape represents a user-provided acknowledgement of letting OMS infer and apply any schema migrations
 * needed to perform a Marketplace installation. Specifically, if the installation requires dropping properties,
 * changing the type of a property, or any other breaking schema modification that requires schema migrations,
 * user acknowledgement of the risk of potential failing cast schema migrations or automatically applied drop
 * migrations is required to proceed with the installation. For more information on schema migrations, refer to
 * the docs on Managing Schema Changes in the Ontology.
 */
interface AllowOntologySchemaMigrationsShape {
    about: LocalizedTitleAndDescription;
}
type AllPossibleVersionsMissingInputsConstraintFailure = Record<BlockSetVersionId, BlockSetVersionMissingInputsConstraintFailure>;
type AllPossibleVersionsMissingInputsConstraintFailureV2 = Record<BlockSetVersionId, BlockSetVersionMissingInputsConstraintFailureV2>;
/**
 * Logical AND - destination function must satisfy ALL nested expressions.
 */
interface AndExpressionIdentifier {
    expressions: Array<ContractExpressionIdentifier>;
}
/**
 * A parameter constraint type requiring an interface object set without specifying the interface type.
 */
interface AnyInterfaceObjectSetRidType {
}
/**
 * A parameter constraint type requiring a list of interface references without specifying the interface type.
 */
interface AnyInterfaceReferenceListType {
}
/**
 * A parameter constraint type requiring an interface reference without specifying the interface type.
 */
interface AnyInterfaceReferenceType {
}
/**
 * A parameter constraint type requiring a list of object references without specifying the object type.
 */
interface AnyObjectReferenceListType {
}
/**
 * A parameter constraint type requiring an object reference without specifying the object type.
 */
interface AnyObjectReferenceType {
}
/**
 * A parameter constraint type requiring an object set without specifying the object type.
 */
interface AnyObjectSetRidType {
}
interface AnySchema {
}
/**
 * A parameter constraint type requiring a list of structs without specifying the struct field definitions.
 */
interface AnyStructListType {
}
/**
 * A parameter constraint type requiring a struct without specifying the struct field definitions.
 */
interface AnyStructType {
}
interface ApiNameResolver {
    apiName: string;
}
/**
 * The names of secrets needed for an Apollo agent to operate. This is only used for unprivileged agents right now.
 */
type ApolloAgentSecretType = "TOFU_SECRET" | "PRIVATE_KEY_PASSPHRASE";
/**
 * Alias of com.palantir.apollo.catalog.api.objects.ArtifactUri
 *
 * Example value: "apollo.palantircloud.com/marketplace/foundryproducts/com.palantirfoundry.stack.namespace/project-123/manifests/1.1.0"
 */
type ApolloArtifactUri = string;
interface ApolloBlockSetPublishingStatus_success {
    type: "success";
    success: BlockSetPublishingJobSuccess;
}
interface ApolloBlockSetPublishingStatus_inProgress {
    type: "inProgress";
    inProgress: BlockSetPublishingJobInProgress;
}
interface ApolloBlockSetPublishingStatus_failure {
    type: "failure";
    failure: BlockSetPublishingJobFailure;
}
type ApolloBlockSetPublishingStatus = ApolloBlockSetPublishingStatus_success | ApolloBlockSetPublishingStatus_inProgress | ApolloBlockSetPublishingStatus_failure;
/**
 * Cross stack manifest top level object
 */
interface ApolloCrossStackManifest {
    stackConfiguration: ApolloStackManagementConfig;
    storeName: StoreName;
}
/**
 * The identifier for an entity in Apollo, an equivalent of com.palantir.apollo.ApolloEntityId, often referred to
 * as "aeid".
 *
 * Marketplace tracks two types of entities:
 * 1. Foundry Product Managed, which have a corresponding MIM installation. Note that a MIM installation may not
 * have a corresponding aeid if it was created through MIM but never managed by Apollo.
 * 2. Foundry Product Artifact. In this case, the entity does not correspond to an actual marketplace
 * installation
 *
 * Example: aeid:mojito:foundry-product:namespace+truck-locator.
 */
type ApolloEntityId = string;
/**
 * A simple wrapper around ApolloEnvironmentId that exposes whether the environment is privileged or not.
 */
interface ApolloEnvironment {
    id: ApolloEnvironmentId;
    privileged: boolean;
}
/**
 * The identifier for the environment that Apollo Manages, from the perspective of the Apollo Space.
 * This is external to Foundry, but is stored in MIM to know which environment a given Apollo Space is
 * considering a installation to be in.
 */
type ApolloEnvironmentId = string;
/**
 * The identifier for a namespace from Apollo's point of view. May be a 1) MavenGroup (when one is
 * set on the namespace), 2) NamespaceRid, or 2) "ARTIFACT". This type only exists to highlight this
 * implicit union and help promote safe handling internally.
 *
 * We consider this value safe because apollo's FoundrySpaceMavenGroup type is safe.
 */
type ApolloFoundrySpaceIdentifier = string;
/**
 * This store will be available to configure in Control Panel for the allowlist organisations that exist
 * on the stack. Allowlisted organizations comprise of the union of all organizations in the allowlisted
 * `enrollmentsRids` and of the `organizationRids`. A given resource identifier cannot appear in both its allowed
 * and disallowed configuration.
 * If the allowed and disallowed configuration options overlap, the organization-level configuration takes
 * precedence over enrollment-level configuration; configurers can disallow an enrollment and allow an
 * organization in that enrollment.
 * By default, the store will be enabled for allowlisted organisations the first time it is installed on a stack.
 *
 * Access expansions cannot be granted on stores that use `ApolloGranularConfig`, and any expansions granted
 * will be ignored.
 */
interface ApolloGranularConfig {
    disallowedEnrollmentRids: Array<EnrollmentRid>;
    disallowedOrganizationRids: Array<OrganizationRid>;
    enrollmentsRids: Array<EnrollmentRid>;
    groupIds: Array<GroupId>;
    organizationRids: Array<OrganizationRid>;
}
/**
 * The base URI to an Apollo.
 * This should be sanitized before use, to account for a protocol prefix or trailing slash.
 */
type ApolloHostUri = string;
/**
 * A uuid identifying an Apollo plan. In practice, always equal to the locator of the corresponding PlanRid.
 */
type ApolloPlanId = string;
/**
 * The rid of an Apollo plan.
 */
type ApolloPlanRid = string;
/**
 * The rid of an Apollo plan task.
 */
type ApolloPlanTaskRid = string;
/**
 * A uniquely identified Apollo secret by its name and key.
 */
interface ApolloSecretAndKeyName {
    secretKeyName: SecretKey;
    secretName: ApolloSecretName;
}
/**
 * The name of a user-defined secret in Apollo. Should only be used in contexts to identify secrets managed in
 * Apollo. Currently, only Apollo multi-key secrets are supported. See also credentials.SecretName
 * and data-connector.MagritteSecretName for disambiguation.
 */
type ApolloSecretName = string;
/**
 * Identifier for a Apollo space managing installations. This is external to Foundry, but is stored
 * in MIM to know which Apollo space is managing a given installation. It is obtained when a agent is reporting
 * its information to Apollo.
 */
type ApolloSpaceId = string;
/**
 * The set of identifiers that are sourced from the Apollo space.
 */
interface ApolloSpaceIdentifiers {
    environmentId: ApolloEnvironmentId;
    spaceId: ApolloSpaceId;
}
interface ApolloSpaceToPublishingStatus {
    apolloSpacePublishingStatus: Record<ApolloSpaceId, ApolloBlockSetPublishingStatus>;
}
interface ApolloStackLevelConfig {
    defaultEnabled?: boolean | null | undefined;
    defaultStoreAccess?: ManagedStoreAccessLevel | null | undefined;
    forceDefault?: boolean | null | undefined;
}
interface ApolloStackManagementConfig_stackLevelConfig {
    type: "stackLevelConfig";
    stackLevelConfig: ApolloStackLevelConfig;
}
interface ApolloStackManagementConfig_granularConfig {
    type: "granularConfig";
    granularConfig: ApolloGranularConfig;
}
/**
 * Type for configuration used by cross stack stores managed through the foundry/marketplace-apollo-bundles repo.
 */
type ApolloStackManagementConfig = ApolloStackManagementConfig_stackLevelConfig | ApolloStackManagementConfig_granularConfig;
interface AppConfigCreateBlockRequest {
    rid: string;
    schemaVersion?: number | null | undefined;
    version?: number | null | undefined;
}
interface AppConfigIdentifier_rid {
    type: "rid";
    rid: string;
}
type AppConfigIdentifier = AppConfigIdentifier_rid;
interface AppConfigOutputShape {
    about: LocalizedTitleAndDescription;
}
interface AppConfigOutputSpecConfig {
    schemaVersion?: number | null | undefined;
}
/**
 * Reference for identifying a recommendation that is applied to the inputs of an installation
 */
interface AppliedExternalRecommendationV2 {
    recommendationSource: ExternalRecommendationSource;
    upstreamBlockSet: BlockSetId;
    upstreamBlockSetInstallation: BlockSetInstallationRid;
}
interface ArrayBaseType {
    elementType: PrimitiveBaseType;
}
/**
 * Represents an Array property type.
 */
interface ArrayObjectPropertyType {
    elementType: PrimitiveObjectPropertyType;
}
/**
 * Creates a Gotham artifacts peer producer profile block for the given peer producer profile rid
 */
interface ArtifactsPeerProducerProfileCreateBlockRequest {
    peerProducerProfileRid: string;
}
interface ArtifactsRepositoryIdentifier {
    rid: ArtifactsRepositoryRid;
}
type ArtifactsRepositoryRid = string;
interface ArtifactsRepositoryShape {
    about: LocalizedTitleAndDescription;
}
interface AsCodeBlockSetMetadata {
    buildToolOrigin: BuildToolOrigin;
    buildToolVersion: string;
    isInPlatform: boolean;
    makerVersion: string;
}
interface AssociatedBlockSetInstallation_newBlockSet {
    type: "newBlockSet";
    newBlockSet: NewAssociatedBlockSetInstallation;
}
interface AssociatedBlockSetInstallation_existingBlockSet {
    type: "existingBlockSet";
    existingBlockSet: ExistingAssociatedBlockSetInstallation;
}
type AssociatedBlockSetInstallation = AssociatedBlockSetInstallation_newBlockSet | AssociatedBlockSetInstallation_existingBlockSet;
/**
 * For an installation associated with a job, this contains the store the product belonged to, the installation
 * rid and the version that the job is trying to install.
 */
interface AssociatedBlockSetInstallationIdentifiers {
    blockSetId: BlockSetId;
    blockSetInstallationRid: BlockSetInstallationRid;
    marketplaceRid: MarketplaceRid;
    targetVersionId: BlockSetVersionId;
}
/**
 * A block install should be referenced exactly once across all BlockSet installs.
 */
interface AssociatedWithMultipleBlockSetInstallations {
    blockSets: Array<BlockSetReference>;
}
/**
 * An output cannot be attached if it's installed by another installation.
 */
interface AttachedOutputCreatedInAnotherInstallation {
    blockInstallationRid: BlockInstallationRid;
    blockSetInstallationRid: BlockSetInstallationRid;
}
/**
 * When attaching outputs for a block, all outputs of the block must be attached. Partial attachment of a block's
 * outputs is not supported.
 */
interface AttachedOutputShapeNotSpecified {
}
type AttachmentId = string;
/**
 * AttachmentListType specifies that this parameter must be a list of Attachment rids.
 */
interface AttachmentListType {
}
interface AttachmentMetadata {
    filename: Filename;
    id: AttachmentId;
    mimeType: MimeType;
}
/**
 * AttachmentType specifies that this parameter must be the rid of an Attachment.
 */
interface AttachmentType {
}
interface AttachResourcesNotSupportedForBlockType {
    attachedOutputShapeIds: Array<BlockShapeId>;
}
interface AttachResourceValidationErrors_attachResourcesNotSupportedForBlockType {
    type: "attachResourcesNotSupportedForBlockType";
    attachResourcesNotSupportedForBlockType: AttachResourcesNotSupportedForBlockType;
}
type AttachResourceValidationErrors = AttachResourceValidationErrors_attachResourcesNotSupportedForBlockType;
interface AudioDecodeFormat_flac {
    type: "flac";
    flac: FlacFormat;
}
interface AudioDecodeFormat_mp2 {
    type: "mp2";
    mp2: Mp2Format;
}
interface AudioDecodeFormat_mp3 {
    type: "mp3";
    mp3: Mp3Format;
}
interface AudioDecodeFormat_mp4 {
    type: "mp4";
    mp4: Mp4AudioContainerFormat;
}
interface AudioDecodeFormat_nistSphere {
    type: "nistSphere";
    nistSphere: NistSphereFormat;
}
interface AudioDecodeFormat_ogg {
    type: "ogg";
    ogg: OggAudioContainerFormat;
}
interface AudioDecodeFormat_wav {
    type: "wav";
    wav: WavFormat;
}
interface AudioDecodeFormat_webm {
    type: "webm";
    webm: WebmAudioContainerFormat;
}
type AudioDecodeFormat = AudioDecodeFormat_flac | AudioDecodeFormat_mp2 | AudioDecodeFormat_mp3 | AudioDecodeFormat_mp4 | AudioDecodeFormat_nistSphere | AudioDecodeFormat_ogg | AudioDecodeFormat_wav | AudioDecodeFormat_webm;
interface AudioSchema {
    format: AudioDecodeFormat;
}
interface AuthoringLibraryIdentifier {
    locator: AuthoringLibraryLocator;
    repositoryRid: ArtifactsRepositoryRid;
}
interface AuthoringLibraryLocator_condaLocator {
    type: "condaLocator";
    condaLocator: CondaLocator;
}
interface AuthoringLibraryLocator_condaLocatorV2 {
    type: "condaLocatorV2";
    condaLocatorV2: CondaLocatorV2;
}
type AuthoringLibraryLocator = AuthoringLibraryLocator_condaLocator | AuthoringLibraryLocator_condaLocatorV2;
/**
 * The authoring library referenced by the resolved shape was not found.
 */
interface AuthoringLibraryNotFoundError {
    artifactsRepositoryRid: ArtifactsRepositoryRid;
    authoringLibraryLocator: string;
}
/**
 * This shape is used to refer to libraries that are produced by repositories created in Authoring.
 */
interface AuthoringLibraryShape {
    about: LocalizedTitleAndDescription;
}
/**
 * DEPRECATED - use AuthoringRepositoryCreateBlockRequestV2 instead as it supports authoring repositories that
 * publish both jobspecs and libraries
 */
interface AuthoringRepositoryCreateBlockRequest {
    environmentIdentificationMethod: AuthoringRepositoryEnvironmentIdentificationMethod;
    repositoryRid: AuthoringRepositoryRid;
    sourceCodePackaging?: RepositorySourceCodePackagingType | null | undefined;
}
interface AuthoringRepositoryCreateBlockRequestV2 {
    commitish?: string | null | undefined;
    enableRedaction?: boolean | null | undefined;
    environmentIdentificationMethod: AuthoringRepositoryEnvironmentIdentificationMethodV2;
    repositoryRid: AuthoringRepositoryRid;
    sourceCodePackaging: RepositorySourceCodePackagingType;
    templatizeSourceCode?: boolean | null | undefined;
}
interface AuthoringRepositoryEnvironmentIdentificationMethod_jobSpecs {
    type: "jobSpecs";
    jobSpecs: JobSpecEnvironmentIdentificationMethod;
}
/**
 * DEPRECATED - use AuthoringRepositoryEnvironmentIdentificationMethodV2 instead as it supports both jobspecs
 * and libraries
 */
type AuthoringRepositoryEnvironmentIdentificationMethod = AuthoringRepositoryEnvironmentIdentificationMethod_jobSpecs;
/**
 * Used during repository packaging to define how the repository should determine the artifacts that make up
 * its run and/or build time environment for packaging in the block. This would break the old API that just
 * supported jobspecs and so we introduce a V2 version here that supports authoring repositories publishing
 * multiple output types, such as jobspecs and libraries.
 */
interface AuthoringRepositoryEnvironmentIdentificationMethodV2 {
    jobSpecs: Array<JobSpecEnvironmentIdentificationMethodV2>;
    libraryLocators: Array<LibraryLocatorEnvironmentIdentificationMethod>;
}
interface AuthoringRepositoryIdentifier {
    rid: AuthoringRepositoryRid;
}
interface AuthoringRepositoryOutputSpecConfig {
    enableRedaction?: boolean | null | undefined;
    jobSpecs?: Array<JobSpecEnvironmentIdentificationMethodV2> | null | undefined;
    library?: Array<LibraryLocatorEnvironmentIdentificationMethod> | null | undefined;
    sourceCodeConfig?: AuthoringRepositorySourceCodeConfig | null | undefined;
    templatizeSourceCode?: boolean | null | undefined;
}
type AuthoringRepositoryReference = BlockInternalId;
type AuthoringRepositoryRid = string;
interface AuthoringRepositoryShape {
    about: LocalizedTitleAndDescription;
}
/**
 * This configuration determines the method by how the source code is packaged from a repository. The available
 * options are:
 * - OMIT_SOURCE_CODE: Excludes the source code.
 * - SHALLOW_CLONE: Packages source code without version control hitory.
 * - DEEP_CLONE:  Packages everything.
 */
type AuthoringRepositorySourceCodeConfig = "OMIT_SOURCE_CODE" | "SHALLOW_CLONE" | "DEEP_CLONE";
interface AutomappedInput {
    level: AutomappingLevel;
    resolvedInput: ResolvedBlockSetInputShape;
}
interface AutomappingLevel_topLevel {
    type: "topLevel";
    topLevel: TopLevelAutomapping;
}
interface AutomappingLevel_childLevel {
    type: "childLevel";
    childLevel: ChildLevelAutomapping;
}
type AutomappingLevel = AutomappingLevel_topLevel | AutomappingLevel_childLevel;
interface AutomationCreateBlockRequest {
    generateCredentialInput?: boolean | null | undefined;
    rid: string;
    version?: number | null | undefined;
}
interface AutomationIdentifier {
    rid: AutomationRid;
}
interface AutomationOutputSpecConfig {
    generateCredentialInput?: boolean | null | undefined;
}
type AutomationRid = string;
interface AutomationShape {
    about: LocalizedTitleAndDescription;
}
interface AutomationStatus_idle {
    type: "idle";
    idle: IdleStatus;
}
interface AutomationStatus_processing {
    type: "processing";
    processing: ProcessingStatus;
}
interface AutomationStatus_failedConstraints {
    type: "failedConstraints";
    failedConstraints: FailedConstraintsStatus;
}
interface AutomationStatus_upgrading {
    type: "upgrading";
    upgrading: UpgradingStatus;
}
type AutomationStatus = AutomationStatus_idle | AutomationStatus_processing | AutomationStatus_failedConstraints | AutomationStatus_upgrading;
interface AutopilotWorkbenchCreateBlockRequest {
    rid: string;
}
interface AutopilotWorkbenchIdentifier {
    rid: AutopilotWorkbenchRid;
}
type AutopilotWorkbenchRid = string;
interface AutopilotWorkbenchShape {
    about: LocalizedTitleAndDescription;
}
interface BaseParameterConstraintType_boolean {
    type: "boolean";
    boolean: BooleanType;
}
interface BaseParameterConstraintType_booleanList {
    type: "booleanList";
    booleanList: BooleanListType;
}
interface BaseParameterConstraintType_integer {
    type: "integer";
    integer: IntegerType;
}
interface BaseParameterConstraintType_integerList {
    type: "integerList";
    integerList: IntegerListType;
}
interface BaseParameterConstraintType_long {
    type: "long";
    long: LongType;
}
interface BaseParameterConstraintType_longList {
    type: "longList";
    longList: LongListType;
}
interface BaseParameterConstraintType_double {
    type: "double";
    double: DoubleType;
}
interface BaseParameterConstraintType_doubleList {
    type: "doubleList";
    doubleList: DoubleListType;
}
interface BaseParameterConstraintType_string {
    type: "string";
    string: StringType;
}
interface BaseParameterConstraintType_stringList {
    type: "stringList";
    stringList: StringListType;
}
interface BaseParameterConstraintType_decimal {
    type: "decimal";
    decimal: DecimalType;
}
interface BaseParameterConstraintType_decimalList {
    type: "decimalList";
    decimalList: DecimalListType;
}
interface BaseParameterConstraintType_geohash {
    type: "geohash";
    geohash: GeohashType;
}
interface BaseParameterConstraintType_geohashList {
    type: "geohashList";
    geohashList: GeohashListType;
}
interface BaseParameterConstraintType_geoshape {
    type: "geoshape";
    geoshape: GeoshapeType;
}
interface BaseParameterConstraintType_geoshapeList {
    type: "geoshapeList";
    geoshapeList: GeoshapeListType;
}
interface BaseParameterConstraintType_timeSeriesReference {
    type: "timeSeriesReference";
    timeSeriesReference: TimeSeriesReferenceType;
}
interface BaseParameterConstraintType_timestamp {
    type: "timestamp";
    timestamp: TimestampType;
}
interface BaseParameterConstraintType_timestampList {
    type: "timestampList";
    timestampList: TimestampListType;
}
interface BaseParameterConstraintType_date {
    type: "date";
    date: DateType;
}
interface BaseParameterConstraintType_dateList {
    type: "dateList";
    dateList: DateListType;
}
interface BaseParameterConstraintType_objectReference {
    type: "objectReference";
    objectReference: ObjectReferenceType;
}
interface BaseParameterConstraintType_objectReferenceList {
    type: "objectReferenceList";
    objectReferenceList: ObjectReferenceListType;
}
interface BaseParameterConstraintType_objectSetRid {
    type: "objectSetRid";
    objectSetRid: ObjectSetRidType;
}
interface BaseParameterConstraintType_interfaceReference {
    type: "interfaceReference";
    interfaceReference: InterfaceReferenceType;
}
interface BaseParameterConstraintType_interfaceReferenceList {
    type: "interfaceReferenceList";
    interfaceReferenceList: InterfaceReferenceListType;
}
interface BaseParameterConstraintType_interfaceObjectSetRid {
    type: "interfaceObjectSetRid";
    interfaceObjectSetRid: InterfaceObjectSetRidType;
}
interface BaseParameterConstraintType_objectTypeReference {
    type: "objectTypeReference";
    objectTypeReference: ObjectTypeReferenceType;
}
interface BaseParameterConstraintType_scenarioReference {
    type: "scenarioReference";
    scenarioReference: ScenarioReferenceType;
}
interface BaseParameterConstraintType_attachment {
    type: "attachment";
    attachment: AttachmentType;
}
interface BaseParameterConstraintType_attachmentList {
    type: "attachmentList";
    attachmentList: AttachmentListType;
}
interface BaseParameterConstraintType_marking {
    type: "marking";
    marking: MarkingType;
}
interface BaseParameterConstraintType_markingList {
    type: "markingList";
    markingList: MarkingListType;
}
interface BaseParameterConstraintType_mediaReference {
    type: "mediaReference";
    mediaReference: MediaReferenceType;
}
interface BaseParameterConstraintType_mediaReferenceList {
    type: "mediaReferenceList";
    mediaReferenceList: MediaReferenceListType;
}
interface BaseParameterConstraintType_geotimeSeriesReference {
    type: "geotimeSeriesReference";
    geotimeSeriesReference: GeotimeSeriesReferenceType;
}
interface BaseParameterConstraintType_geotimeSeriesReferenceList {
    type: "geotimeSeriesReferenceList";
    geotimeSeriesReferenceList: GeotimeSeriesReferenceListType;
}
interface BaseParameterConstraintType_struct {
    type: "struct";
    struct: StructType;
}
interface BaseParameterConstraintType_structList {
    type: "structList";
    structList: StructListType;
}
interface BaseParameterConstraintType_anyObjectReference {
    type: "anyObjectReference";
    anyObjectReference: AnyObjectReferenceType;
}
interface BaseParameterConstraintType_anyObjectReferenceList {
    type: "anyObjectReferenceList";
    anyObjectReferenceList: AnyObjectReferenceListType;
}
interface BaseParameterConstraintType_anyObjectSetRid {
    type: "anyObjectSetRid";
    anyObjectSetRid: AnyObjectSetRidType;
}
interface BaseParameterConstraintType_anyInterfaceReference {
    type: "anyInterfaceReference";
    anyInterfaceReference: AnyInterfaceReferenceType;
}
interface BaseParameterConstraintType_anyInterfaceReferenceList {
    type: "anyInterfaceReferenceList";
    anyInterfaceReferenceList: AnyInterfaceReferenceListType;
}
interface BaseParameterConstraintType_anyInterfaceObjectSetRid {
    type: "anyInterfaceObjectSetRid";
    anyInterfaceObjectSetRid: AnyInterfaceObjectSetRidType;
}
interface BaseParameterConstraintType_anyStruct {
    type: "anyStruct";
    anyStruct: AnyStructType;
}
interface BaseParameterConstraintType_anyStructList {
    type: "anyStructList";
    anyStructList: AnyStructListType;
}
/**
 * All possible types for parameter constraints on InterfaceActionTypeConstraints.
 * Mirrors com.palantir.ontology.metadata.api.types.BaseParameterConstraintType from the
 * ontology-metadata-service API.
 *
 * This union includes all BaseParameterType variants plus additional "any"-prefixed constraint
 * variants (e.g., anyObjectReference, anyStruct). The "any" variants are part of the OMS
 * interface parameter constraint API — they define constraints that don't specify a concrete
 * entity (e.g., "any object reference" rather than "a reference to a specific object type").
 * See the any-prefixed members below for details.
 */
type BaseParameterConstraintType = BaseParameterConstraintType_boolean | BaseParameterConstraintType_booleanList | BaseParameterConstraintType_integer | BaseParameterConstraintType_integerList | BaseParameterConstraintType_long | BaseParameterConstraintType_longList | BaseParameterConstraintType_double | BaseParameterConstraintType_doubleList | BaseParameterConstraintType_string | BaseParameterConstraintType_stringList | BaseParameterConstraintType_decimal | BaseParameterConstraintType_decimalList | BaseParameterConstraintType_geohash | BaseParameterConstraintType_geohashList | BaseParameterConstraintType_geoshape | BaseParameterConstraintType_geoshapeList | BaseParameterConstraintType_timeSeriesReference | BaseParameterConstraintType_timestamp | BaseParameterConstraintType_timestampList | BaseParameterConstraintType_date | BaseParameterConstraintType_dateList | BaseParameterConstraintType_objectReference | BaseParameterConstraintType_objectReferenceList | BaseParameterConstraintType_objectSetRid | BaseParameterConstraintType_interfaceReference | BaseParameterConstraintType_interfaceReferenceList | BaseParameterConstraintType_interfaceObjectSetRid | BaseParameterConstraintType_objectTypeReference | BaseParameterConstraintType_scenarioReference | BaseParameterConstraintType_attachment | BaseParameterConstraintType_attachmentList | BaseParameterConstraintType_marking | BaseParameterConstraintType_markingList | BaseParameterConstraintType_mediaReference | BaseParameterConstraintType_mediaReferenceList | BaseParameterConstraintType_geotimeSeriesReference | BaseParameterConstraintType_geotimeSeriesReferenceList | BaseParameterConstraintType_struct | BaseParameterConstraintType_structList | BaseParameterConstraintType_anyObjectReference | BaseParameterConstraintType_anyObjectReferenceList | BaseParameterConstraintType_anyObjectSetRid | BaseParameterConstraintType_anyInterfaceReference | BaseParameterConstraintType_anyInterfaceReferenceList | BaseParameterConstraintType_anyInterfaceObjectSetRid | BaseParameterConstraintType_anyStruct | BaseParameterConstraintType_anyStructList;
interface BaseParameterType_boolean {
    type: "boolean";
    boolean: BooleanType;
}
interface BaseParameterType_booleanList {
    type: "booleanList";
    booleanList: BooleanListType;
}
interface BaseParameterType_integer {
    type: "integer";
    integer: IntegerType;
}
interface BaseParameterType_integerList {
    type: "integerList";
    integerList: IntegerListType;
}
interface BaseParameterType_long {
    type: "long";
    long: LongType;
}
interface BaseParameterType_longList {
    type: "longList";
    longList: LongListType;
}
interface BaseParameterType_double {
    type: "double";
    double: DoubleType;
}
interface BaseParameterType_doubleList {
    type: "doubleList";
    doubleList: DoubleListType;
}
interface BaseParameterType_string {
    type: "string";
    string: StringType;
}
interface BaseParameterType_stringList {
    type: "stringList";
    stringList: StringListType;
}
interface BaseParameterType_decimal {
    type: "decimal";
    decimal: DecimalType;
}
interface BaseParameterType_decimalList {
    type: "decimalList";
    decimalList: DecimalListType;
}
interface BaseParameterType_geohash {
    type: "geohash";
    geohash: GeohashType;
}
interface BaseParameterType_geohashList {
    type: "geohashList";
    geohashList: GeohashListType;
}
interface BaseParameterType_geoshape {
    type: "geoshape";
    geoshape: GeoshapeType;
}
interface BaseParameterType_geoshapeList {
    type: "geoshapeList";
    geoshapeList: GeoshapeListType;
}
interface BaseParameterType_timeSeriesReference {
    type: "timeSeriesReference";
    timeSeriesReference: TimeSeriesReferenceType;
}
interface BaseParameterType_timestamp {
    type: "timestamp";
    timestamp: TimestampType;
}
interface BaseParameterType_timestampList {
    type: "timestampList";
    timestampList: TimestampListType;
}
interface BaseParameterType_date {
    type: "date";
    date: DateType;
}
interface BaseParameterType_dateList {
    type: "dateList";
    dateList: DateListType;
}
interface BaseParameterType_objectReference {
    type: "objectReference";
    objectReference: ObjectReferenceType;
}
interface BaseParameterType_objectReferenceList {
    type: "objectReferenceList";
    objectReferenceList: ObjectReferenceListType;
}
interface BaseParameterType_objectSetRid {
    type: "objectSetRid";
    objectSetRid: ObjectSetRidType;
}
interface BaseParameterType_interfaceReference {
    type: "interfaceReference";
    interfaceReference: InterfaceReferenceType;
}
interface BaseParameterType_interfaceReferenceList {
    type: "interfaceReferenceList";
    interfaceReferenceList: InterfaceReferenceListType;
}
interface BaseParameterType_interfaceObjectSetRid {
    type: "interfaceObjectSetRid";
    interfaceObjectSetRid: InterfaceObjectSetRidType;
}
interface BaseParameterType_objectTypeReference {
    type: "objectTypeReference";
    objectTypeReference: ObjectTypeReferenceType;
}
interface BaseParameterType_attachment {
    type: "attachment";
    attachment: AttachmentType;
}
interface BaseParameterType_attachmentList {
    type: "attachmentList";
    attachmentList: AttachmentListType;
}
interface BaseParameterType_marking {
    type: "marking";
    marking: MarkingType;
}
interface BaseParameterType_markingList {
    type: "markingList";
    markingList: MarkingListType;
}
interface BaseParameterType_mediaReference {
    type: "mediaReference";
    mediaReference: MediaReferenceType;
}
interface BaseParameterType_geotimeSeriesReference {
    type: "geotimeSeriesReference";
    geotimeSeriesReference: GeotimeSeriesReferenceType;
}
interface BaseParameterType_geotimeSeriesReferenceList {
    type: "geotimeSeriesReferenceList";
    geotimeSeriesReferenceList: GeotimeSeriesReferenceListType;
}
interface BaseParameterType_scenarioReference {
    type: "scenarioReference";
    scenarioReference: ScenarioReferenceType;
}
interface BaseParameterType_struct {
    type: "struct";
    struct: StructType;
}
interface BaseParameterType_structList {
    type: "structList";
    structList: StructListType;
}
/**
 * All of the possible types for Parameters.
 */
type BaseParameterType = BaseParameterType_boolean | BaseParameterType_booleanList | BaseParameterType_integer | BaseParameterType_integerList | BaseParameterType_long | BaseParameterType_longList | BaseParameterType_double | BaseParameterType_doubleList | BaseParameterType_string | BaseParameterType_stringList | BaseParameterType_decimal | BaseParameterType_decimalList | BaseParameterType_geohash | BaseParameterType_geohashList | BaseParameterType_geoshape | BaseParameterType_geoshapeList | BaseParameterType_timeSeriesReference | BaseParameterType_timestamp | BaseParameterType_timestampList | BaseParameterType_date | BaseParameterType_dateList | BaseParameterType_objectReference | BaseParameterType_objectReferenceList | BaseParameterType_objectSetRid | BaseParameterType_interfaceReference | BaseParameterType_interfaceReferenceList | BaseParameterType_interfaceObjectSetRid | BaseParameterType_objectTypeReference | BaseParameterType_attachment | BaseParameterType_attachmentList | BaseParameterType_marking | BaseParameterType_markingList | BaseParameterType_mediaReference | BaseParameterType_geotimeSeriesReference | BaseParameterType_geotimeSeriesReferenceList | BaseParameterType_scenarioReference | BaseParameterType_struct | BaseParameterType_structList;
interface BaseType_primitive {
    type: "primitive";
    primitive: PrimitiveBaseType;
}
interface BaseType_array {
    type: "array";
    array: ArrayBaseType;
}
interface BaseType_structV2 {
    type: "structV2";
    structV2: StructV2BaseType;
}
type BaseType = BaseType_primitive | BaseType_array | BaseType_structV2;
interface BatchEditBlockSetVersionError_draftGroupNotEditable {
    type: "draftGroupNotEditable";
    draftGroupNotEditable: Void;
}
interface BatchEditBlockSetVersionError_editPermissionDenied {
    type: "editPermissionDenied";
    editPermissionDenied: BatchEditPermissionDeniedError;
}
interface BatchEditBlockSetVersionError_notFound {
    type: "notFound";
    notFound: Void;
}
interface BatchEditBlockSetVersionError_notInEditableState {
    type: "notInEditableState";
    notInEditableState: Void;
}
interface BatchEditBlockSetVersionError_ownedByOtherUser {
    type: "ownedByOtherUser";
    ownedByOtherUser: BatchOwnedByOtherUserError;
}
/**
 * Describes why a specific block set version could not be edited in a batch update operation.
 */
type BatchEditBlockSetVersionError = BatchEditBlockSetVersionError_draftGroupNotEditable | BatchEditBlockSetVersionError_editPermissionDenied | BatchEditBlockSetVersionError_notFound | BatchEditBlockSetVersionError_notInEditableState | BatchEditBlockSetVersionError_ownedByOtherUser;
interface BatchEditPermissionDeniedError {
    marketplaceRid: MarketplaceRid;
}
interface BatchGetApolloBlockSetVersionPublishingStatusRequest {
    blockSetVersionIds: Array<BlockSetVersionId>;
}
interface BatchGetApolloBlockSetVersionPublishingStatusResponse {
    blockSetVersionIdToSpacesStatus: Record<BlockSetVersionId, ApolloSpaceToPublishingStatus>;
}
interface BatchGetBlockInstallationJobsRequest {
    jobRids: Array<InstallBlocksJobRid>;
}
interface BatchGetBlockInstallationJobsResponse {
    jobs: Record<InstallBlocksJobRid, BlockInstallationJob>;
}
interface BatchGetBlockInstallationsRequest {
    blockInstallationRids: Array<BlockInstallationRid>;
}
interface BatchGetBlockInstallationsResponse {
    blockInstallations: Record<BlockInstallationRid, BlockInstallation>;
}
interface BatchGetBlockSetVersionStatusV3Request {
    blockSetVersionIds: Array<BlockSetVersionId>;
}
interface BatchGetBlockSetVersionStatusV3Response {
    statuses: Record<BlockSetVersionId, BlockSetVersionStatusV3>;
}
interface BatchGetInstallableBlockSetVersionsRequest {
    blockSetVersionIds: Array<BlockSetVersionId>;
}
interface BatchGetInstallableBlockSetVersionsResponse {
    responses: Record<BlockSetVersionId, GetInstallableBlockSetVersionResponse>;
}
interface BatchGetInstallableBlockVersionRequest {
    blockVersions: Array<BlockVersionId>;
}
interface BatchGetInstallableBlockVersionResponse {
    responses: Record<BlockVersionId, GetInstallableBlockVersionResponse>;
}
interface BatchGetPendingBlockSetVersionMetadataRequest {
    blockSetVersionIds: Array<BlockSetVersionId>;
}
interface BatchGetPendingBlockSetVersionMetadataResponse {
    metadata: Record<BlockSetVersionId, PendingBlockSetVersionMetadata>;
}
interface BatchOwnedByOtherUserError {
    owningUser: MultipassUserId;
}
interface BatchUpdatePendingBlockSetVersionMetadataRequestItemV3 {
    blockSetVersionId: BlockSetVersionId;
    request: UpdatePendingBlockSetVersionMetadataRequestV3;
}
interface BatchUpdatePendingBlockSetVersionMetadataRequestV3 {
    requests: Array<BatchUpdatePendingBlockSetVersionMetadataRequestItemV3>;
}
interface BatchUpdatePendingBlockSetVersionMetadataResponseV3 {
}
/**
 * Updates metadata for multiple pending input block set shapes in a single request.
 * All updates are applied atomically in a single transaction.
 */
interface BatchUpdatePendingInputShapeMetadataRequest {
    updates: Record<InputBlockSetShapeId, UpdatePendingInputShapeMetadataRequest>;
}
interface BatchUpdatePendingInputShapeMetadataResponse {
}
interface BlobsterCreateBlockRequest {
    rid: string;
}
interface BlobsterInputIdentifier {
    allowedTypes: Array<BlobsterResourceType>;
    rid: BlobsterRid;
}
interface BlobsterOutputIdentifier {
    rid: BlobsterRid;
}
interface BlobsterResourceInputShape {
    about: LocalizedTitleAndDescription;
    allowedTypes: Array<BlobsterResourceType>;
}
/**
 * The type of this resource does not match one of the allowed types.
 */
interface BlobsterResourceInputShapeTypeMismatch {
    actual: ResourceType;
    expected: Array<BlobsterResourceType>;
}
interface BlobsterResourceOutputShape {
    about: LocalizedTitleAndDescription;
    type?: BlobsterResourceType | null | undefined;
}
/**
 * The service to which rid belongs is different from the one that was expected.
 */
interface BlobsterResourceShapeServiceMismatch {
    actual: ServiceName;
    expected: ServiceName;
}
/**
 * Represents the type of a Blobster resource. Should be the type from the RID in UPPERCASE. E.g. for an image
 * resource with RID `ri.blobster.main.image.<uuid>`, the resource type would be `IMAGE`.
 */
type BlobsterResourceType = "IMAGE" | "DOCUMENT" | "CODE" | "BLOB";
type BlobsterRid = string;
interface Block {
    blockVersionId: BlockVersionId;
    id: BlockId;
    internal: BlockInternal;
    version: BlockVersion;
}
interface BlockCreationError_aborted {
    type: "aborted";
    aborted: Void;
}
interface BlockCreationError_dataUploadTimeout {
    type: "dataUploadTimeout";
    dataUploadTimeout: BlockCreationErrorDataUploadTimeout;
}
interface BlockCreationError_dataUploadFailed {
    type: "dataUploadFailed";
    dataUploadFailed: BlockCreationErrorDataUploadFailed;
}
interface BlockCreationError_generic {
    type: "generic";
    generic: BlockCreationErrorGeneric;
}
type BlockCreationError = BlockCreationError_aborted | BlockCreationError_dataUploadTimeout | BlockCreationError_dataUploadFailed | BlockCreationError_generic;
interface BlockCreationErrorDataUploadFailed {
    error?: MarketplaceSerializableError | null | undefined;
    errorInstanceId?: ErrorInstanceId | null | undefined;
    errorMessage: string;
}
interface BlockCreationErrorDataUploadTimeout {
    timeoutSeconds: number;
}
interface BlockCreationErrorGeneric {
    errorInstanceId?: ErrorInstanceId | null | undefined;
    errorMessage: string;
}
/**
 * An identifier for a piece of block data. These can be referenced from e.g. stored manifest files, and/or in
 * `BlockSpecificConfiguration`.
 */
type BlockDataId = BlockInternalId;
interface BlockDisplayMetadata {
    about: LocalizedTitleAndDescription;
}
/**
 * Unique identifier for a particular block that stays constant across versions.
 */
type BlockId = string;
interface BlockIdAndType {
    blockId: BlockId;
    blockType: BlockType;
}
/**
 * The sum of the input shapes of all blocks in the block set.
 */
interface BlockInputShapeSizeLimitCount {
    inputShapeLimit: number;
    numberOfInputShapes: number;
    thresholdPercent: number;
}
interface BlockInstallActionParameterTypeShapeError_parameterNotFound {
    type: "parameterNotFound";
    parameterNotFound: ActionParameterNotFound;
}
interface BlockInstallActionParameterTypeShapeError_requiredParameterMissing {
    type: "requiredParameterMissing";
    requiredParameterMissing: RequiredActionParameterTypeShapeMissing;
}
interface BlockInstallActionParameterTypeShapeError_shapeNotFound {
    type: "shapeNotFound";
    shapeNotFound: ActionParameterTypeShapeNotFound;
}
interface BlockInstallActionParameterTypeShapeError_shapeTypeMismatch {
    type: "shapeTypeMismatch";
    shapeTypeMismatch: ActionParameterTypeShapeTypeMismatch;
}
interface BlockInstallActionParameterTypeShapeError_shapeTypeObjectTypeIdUnresolvable {
    type: "shapeTypeObjectTypeIdUnresolvable";
    shapeTypeObjectTypeIdUnresolvable: ActionParameterShapeTypeObjectTypeIdUnresolvable;
}
interface BlockInstallActionParameterTypeShapeError_shapeTypeInterfaceTypeRidUnresolvable {
    type: "shapeTypeInterfaceTypeRidUnresolvable";
    shapeTypeInterfaceTypeRidUnresolvable: ActionParameterShapeTypeInterfaceTypeRidUnresolvable;
}
interface BlockInstallActionParameterTypeShapeError_shapeTypeUnknown {
    type: "shapeTypeUnknown";
    shapeTypeUnknown: ActionParameterTypeShapeTypeUnknown;
}
/**
 * Errors specific to ActionParameterTypeShape(s).
 */
type BlockInstallActionParameterTypeShapeError = BlockInstallActionParameterTypeShapeError_parameterNotFound | BlockInstallActionParameterTypeShapeError_requiredParameterMissing | BlockInstallActionParameterTypeShapeError_shapeNotFound | BlockInstallActionParameterTypeShapeError_shapeTypeMismatch | BlockInstallActionParameterTypeShapeError_shapeTypeObjectTypeIdUnresolvable | BlockInstallActionParameterTypeShapeError_shapeTypeInterfaceTypeRidUnresolvable | BlockInstallActionParameterTypeShapeError_shapeTypeUnknown;
interface BlockInstallActionTypeParameterShapeErrorV2_shapeTypeMismatch {
    type: "shapeTypeMismatch";
    shapeTypeMismatch: ActionParameterTypeShapeTypeMismatch;
}
interface BlockInstallActionTypeParameterShapeErrorV2_shapeTypeObjectTypeIdUnresolvable {
    type: "shapeTypeObjectTypeIdUnresolvable";
    shapeTypeObjectTypeIdUnresolvable: ActionParameterShapeTypeObjectTypeIdUnresolvable;
}
interface BlockInstallActionTypeParameterShapeErrorV2_shapeTypeInterfaceTypeRidUnresolvable {
    type: "shapeTypeInterfaceTypeRidUnresolvable";
    shapeTypeInterfaceTypeRidUnresolvable: ActionParameterShapeTypeInterfaceTypeRidUnresolvable;
}
interface BlockInstallActionTypeParameterShapeErrorV2_shapeTypeUnknown {
    type: "shapeTypeUnknown";
    shapeTypeUnknown: ActionParameterTypeShapeTypeUnknown;
}
/**
 * Errors specific to ActionParameterTypeShape(s).
 */
type BlockInstallActionTypeParameterShapeErrorV2 = BlockInstallActionTypeParameterShapeErrorV2_shapeTypeMismatch | BlockInstallActionTypeParameterShapeErrorV2_shapeTypeObjectTypeIdUnresolvable | BlockInstallActionTypeParameterShapeErrorV2_shapeTypeInterfaceTypeRidUnresolvable | BlockInstallActionTypeParameterShapeErrorV2_shapeTypeUnknown;
/**
 * A block installation records that a block has been installed in a given installation context.
 */
interface BlockInstallation {
    blockId: BlockId;
    blockInstallationRid: BlockInstallationRid;
    blockVersionId: BlockVersionId;
    installationTimestamp: InstallationTimestamp;
    resolvedInputGroups: Record<InputGroupId, ResolvedInputGroup>;
    resolvedInputs: Record<BlockShapeId, BlockInstallationResolvedInput>;
    resolvedOutputs: Record<BlockShapeId, BlockInstallationResolvedOutput>;
    updatedAtTimestamp: UpdatedAtTimestamp;
}
/**
 * DEPRECATED: Use `BlockInstallLocation` instead.
 *
 * The installation context passed to services when doing a single block install/upgrade/preallocation.
 * Note that this type may deviate over time from the more general installation context.
 * This block-level one may differ between blocks in the same install request/blockset/etc.
 */
interface BlockInstallationContext {
    compass: CompassContext;
    id: InstallationContextId;
    ontology: OntologyContext;
}
/**
 * Shape groups are installed at the same time and are affected by the same error.
 */
interface BlockInstallationFailure {
    affectedShapes: Array<OutputBlockSetShapeId>;
    blockError: BlockInstallError;
    blockType: BlockType;
}
/**
 * Shape groups are installed at the same time and are affected by the same error.
 */
interface BlockInstallationFailureV2 {
    affectedShapes: Array<OutputBlockSetShapeId>;
    blockType: BlockType;
    error: MarketplaceSerializableError;
}
/**
 * Unique identifier for a block that is being requested for install or upgrade.
 */
type BlockInstallationId = string;
/**
 * DEPRECATED. Use `BlockSetInstallationJob`.
 */
interface BlockInstallationJob {
    associatedInstallations: Array<AssociatedBlockSetInstallationIdentifiers>;
    buildsFinishedAtTimestamp?: BuildsFinishedAtTimestamp | null | undefined;
    cleanupUnusedShapesStatuses: Record<BlockSetInstallationRid, CleanupUnusedShapesStatuses>;
    installationCreator: MultipassUserId;
    installationRequestTimestamp: InstallationTimestamp;
    installBlockSetsRequest?: InstallBlockSetsRequest | null | undefined;
    installRequest: InstallBlocksRequest;
    isPendingCancellation: boolean;
    marketplaceRid: MarketplaceRid;
    status: InstallBlocksStatus;
    updatedAtTimestamp: UpdatedAtTimestamp;
}
/**
 * Refers to an output shape of a specific block installation.
 * i.e. Unlike an OutputReference, the block is referred to always via a BlockInstallationRid.
 */
interface BlockInstallationOutputReference {
    blockInstallationRid: BlockInstallationRid;
    outputShapeId: BlockShapeId;
}
interface BlockInstallationResolvedInput {
    fromOutput?: BlockInstallationOutputReference | null | undefined;
    resolvedInput: ResolvedInputShape;
}
interface BlockInstallationResolvedOutput {
    manuallyProvided: boolean;
    resolvedOutput: ResolvedOutputShape;
}
/**
 * Identifies a block installation.
 */
type BlockInstallationRid = string;
interface BlockInstallBlobsterResourceShapeError_serviceMismatch {
    type: "serviceMismatch";
    serviceMismatch: BlobsterResourceShapeServiceMismatch;
}
interface BlockInstallBlobsterResourceShapeError_typeMismatch {
    type: "typeMismatch";
    typeMismatch: BlobsterResourceInputShapeTypeMismatch;
}
type BlockInstallBlobsterResourceShapeError = BlockInstallBlobsterResourceShapeError_serviceMismatch | BlockInstallBlobsterResourceShapeError_typeMismatch;
/**
 * The Column referenced by the resolved shape was not found.
 */
interface BlockInstallColumnNotFound {
    column: string;
    datasourceLocator: DatasourceLocator;
}
interface BlockInstallColumnShapeError_typeMismatch {
    type: "typeMismatch";
    typeMismatch: ColumnTypeMismatch;
}
interface BlockInstallColumnShapeError_datasourceReferenceMismatch {
    type: "datasourceReferenceMismatch";
    datasourceReferenceMismatch: TabularDatasourceReferenceMismatch;
}
interface BlockInstallColumnShapeError_datasourceReferenceUnresolvable {
    type: "datasourceReferenceUnresolvable";
    datasourceReferenceUnresolvable: TabularDatasourceReferenceUnresolvable;
}
interface BlockInstallColumnShapeError_missingColumnTypeClass {
    type: "missingColumnTypeClass";
    missingColumnTypeClass: MissingColumnTypeClass;
}
type BlockInstallColumnShapeError = BlockInstallColumnShapeError_typeMismatch | BlockInstallColumnShapeError_datasourceReferenceMismatch | BlockInstallColumnShapeError_datasourceReferenceUnresolvable | BlockInstallColumnShapeError_missingColumnTypeClass;
/**
 * The Compass resource referenced by the resolved shape is trashed in Compass. The resource needs to be
 * restored from trash to be used in the install.
 */
interface BlockInstallCompassResourceInTrash {
    rid: string;
}
interface BlockInstallCompassResourceShapeError_typeMismatch {
    type: "typeMismatch";
    typeMismatch: CompassResourceInputShapeTypeMismatch;
}
interface BlockInstallCompassResourceShapeError_outputTypeMismatch {
    type: "outputTypeMismatch";
    outputTypeMismatch: CompassResourceOutputShapeTypeMismatch;
}
type BlockInstallCompassResourceShapeError = BlockInstallCompassResourceShapeError_typeMismatch | BlockInstallCompassResourceShapeError_outputTypeMismatch;
/**
 * The connection was not found on the provided source.
 */
interface BlockInstallConnectionNotFoundError {
    connectionId: MagritteConnectionId;
    sourceRid: MagritteSourceRid;
}
/**
 * The connection on the input shape references a different magritteSource than the one on the resolved shape.
 */
interface BlockInstallConnectionReferenceMismatchError {
}
/**
 * The connection on the input shape cannot be matched with the connection on the resolved shape.
 * This is typical if the referenced Magritte source source has not been included as an input to the block.
 */
interface BlockInstallConnectionReferenceUnresolvableError {
}
interface BlockInstallError_installFailure {
    type: "installFailure";
    installFailure: BlockInstallFailure;
}
interface BlockInstallError_buildFailure {
    type: "buildFailure";
    buildFailure: BuildFailure;
}
interface BlockInstallError_buildTimeout {
    type: "buildTimeout";
    buildTimeout: BuildTimeout;
}
interface BlockInstallError_installTimedOut {
    type: "installTimedOut";
    installTimedOut: Void;
}
interface BlockInstallError_inputDependencyCycles {
    type: "inputDependencyCycles";
    inputDependencyCycles: BlockInstallInputDependencyCycles;
}
interface BlockInstallError_noProcessableInstallationInstructions {
    type: "noProcessableInstallationInstructions";
    noProcessableInstallationInstructions: Void;
}
interface BlockInstallError_illegalRequestError {
    type: "illegalRequestError";
    illegalRequestError: Void;
}
interface BlockInstallError_failedToDeleteResources {
    type: "failedToDeleteResources";
    failedToDeleteResources: FailedToDeleteResourcesError;
}
interface BlockInstallError_indexFailure {
    type: "indexFailure";
    indexFailure: IndexFailure;
}
interface BlockInstallError_reconcileBlockInstallationResponseError {
    type: "reconcileBlockInstallationResponseError";
    reconcileBlockInstallationResponseError: BlockInstallReconcileError;
}
interface BlockInstallError_buildOrchestrationFailure {
    type: "buildOrchestrationFailure";
    buildOrchestrationFailure: BuildOrchestrationFailure;
}
/**
 * Block API level installation error. Errors may relate to specific blocks, or the job as a whole.
 */
type BlockInstallError = BlockInstallError_installFailure | BlockInstallError_buildFailure | BlockInstallError_buildTimeout | BlockInstallError_installTimedOut | BlockInstallError_inputDependencyCycles | BlockInstallError_noProcessableInstallationInstructions | BlockInstallError_illegalRequestError | BlockInstallError_failedToDeleteResources | BlockInstallError_indexFailure | BlockInstallError_reconcileBlockInstallationResponseError | BlockInstallError_buildOrchestrationFailure;
/**
 * Either a generic integration error or marketplace error.
 */
interface BlockInstallFailure {
    args: Array<ErrorArg>;
    message: string;
}
/**
 * The provided Flink profile name is not found in streaming profile service.
 */
interface BlockInstallFlinkProfileNotFound {
    profileName: FlinkProfileName;
}
/**
 * The Function referenced by the resolved input shape was not found.
 */
interface BlockInstallFunctionNotFound {
    functionRid: FunctionRid;
    functionVersion: FunctionVersion;
}
interface BlockInstallFunctionShapeError_contractNotImplemented {
    type: "contractNotImplemented";
    contractNotImplemented: FunctionContractNotImplemented;
}
interface BlockInstallFunctionShapeError_doesNotSatisfyContractExpression {
    type: "doesNotSatisfyContractExpression";
    doesNotSatisfyContractExpression: FunctionDoesNotSatisfyContractExpression;
}
interface BlockInstallFunctionShapeError_customTypeDataTypeActionTypeReferencesUnsupported {
    type: "customTypeDataTypeActionTypeReferencesUnsupported";
    customTypeDataTypeActionTypeReferencesUnsupported: FunctionCustomTypeDataTypeActionTypeReferencesNotSupported;
}
interface BlockInstallFunctionShapeError_customTypeDataTypeCustomTypeNotFound {
    type: "customTypeDataTypeCustomTypeNotFound";
    customTypeDataTypeCustomTypeNotFound: FunctionCustomTypeDataTypeCustomTypeNotFound;
}
interface BlockInstallFunctionShapeError_customTypeDataTypeInterfaceTypeUnresolvable {
    type: "customTypeDataTypeInterfaceTypeUnresolvable";
    customTypeDataTypeInterfaceTypeUnresolvable: FunctionCustomTypeDataTypeInterfaceTypeUnresolvable;
}
interface BlockInstallFunctionShapeError_customTypeDataTypeMarkingSubTypeUnknown {
    type: "customTypeDataTypeMarkingSubTypeUnknown";
    customTypeDataTypeMarkingSubTypeUnknown: FunctionCustomTypeDataTypeMarkingSubTypeUnknown;
}
interface BlockInstallFunctionShapeError_customTypeDataTypeObjectTypeUnresolvable {
    type: "customTypeDataTypeObjectTypeUnresolvable";
    customTypeDataTypeObjectTypeUnresolvable: FunctionCustomTypeDataTypeObjectTypeUnresolvable;
}
interface BlockInstallFunctionShapeError_customTypeDataTypeUnknown {
    type: "customTypeDataTypeUnknown";
    customTypeDataTypeUnknown: FunctionCustomTypeDataTypeUnknown;
}
interface BlockInstallFunctionShapeError_dataTypeValueTypeUnresolvable {
    type: "dataTypeValueTypeUnresolvable";
    dataTypeValueTypeUnresolvable: FunctionDataTypeValueTypeUnresolvable;
}
interface BlockInstallFunctionShapeError_dataTypeValueTypeUnresolvableV2 {
    type: "dataTypeValueTypeUnresolvableV2";
    dataTypeValueTypeUnresolvableV2: FunctionDataTypeValueTypeUnresolvableV2;
}
interface BlockInstallFunctionShapeError_incompatibleContractSemverBlocking {
    type: "incompatibleContractSemverBlocking";
    incompatibleContractSemverBlocking: IncompatibleContractSemverError;
}
interface BlockInstallFunctionShapeError_incompatibleContractSemverNonBlocking {
    type: "incompatibleContractSemverNonBlocking";
    incompatibleContractSemverNonBlocking: IncompatibleContractSemverError;
}
interface BlockInstallFunctionShapeError_inputDataTypeActionTypeReferencesUnsupported {
    type: "inputDataTypeActionTypeReferencesUnsupported";
    inputDataTypeActionTypeReferencesUnsupported: FunctionInputDataTypeActionTypeReferencesUnsupported;
}
interface BlockInstallFunctionShapeError_inputDataTypeActionTypeReferencesUnsupportedV2 {
    type: "inputDataTypeActionTypeReferencesUnsupportedV2";
    inputDataTypeActionTypeReferencesUnsupportedV2: FunctionInputDataTypeActionTypeReferencesUnsupportedV2;
}
interface BlockInstallFunctionShapeError_inputDataTypeCustomTypeNotFound {
    type: "inputDataTypeCustomTypeNotFound";
    inputDataTypeCustomTypeNotFound: FunctionInputDataTypeCustomTypeNotFound;
}
interface BlockInstallFunctionShapeError_inputDataTypeCustomTypeNotFoundV2 {
    type: "inputDataTypeCustomTypeNotFoundV2";
    inputDataTypeCustomTypeNotFoundV2: FunctionInputDataTypeCustomTypeNotFoundV2;
}
interface BlockInstallFunctionShapeError_inputDataTypeInterfaceTypeUnresolvable {
    type: "inputDataTypeInterfaceTypeUnresolvable";
    inputDataTypeInterfaceTypeUnresolvable: FunctionInputDataTypeInterfaceTypeRidUnresolvable;
}
interface BlockInstallFunctionShapeError_inputDataTypeMarkingSubTypeUnknown {
    type: "inputDataTypeMarkingSubTypeUnknown";
    inputDataTypeMarkingSubTypeUnknown: FunctionInputDataTypeMarkingSubTypeUnknown;
}
interface BlockInstallFunctionShapeError_inputDataTypeMarkingSubTypeUnknownV2 {
    type: "inputDataTypeMarkingSubTypeUnknownV2";
    inputDataTypeMarkingSubTypeUnknownV2: FunctionInputDataTypeMarkingSubTypeUnknownV2;
}
interface BlockInstallFunctionShapeError_inputDataTypeMismatch {
    type: "inputDataTypeMismatch";
    inputDataTypeMismatch: FunctionInputDataTypeMismatch;
}
interface BlockInstallFunctionShapeError_inputDataTypeMismatchV2 {
    type: "inputDataTypeMismatchV2";
    inputDataTypeMismatchV2: FunctionInputDataTypeMismatchV2;
}
interface BlockInstallFunctionShapeError_inputDataTypeObjectTypeUnresolvable {
    type: "inputDataTypeObjectTypeUnresolvable";
    inputDataTypeObjectTypeUnresolvable: FunctionInputDataTypeObjectTypeIdUnresolvable;
}
interface BlockInstallFunctionShapeError_inputDataTypeObjectTypeUnresolvableV2 {
    type: "inputDataTypeObjectTypeUnresolvableV2";
    inputDataTypeObjectTypeUnresolvableV2: FunctionInputDataTypeObjectTypeIdUnresolvableV2;
}
interface BlockInstallFunctionShapeError_inputDataTypeUnknown {
    type: "inputDataTypeUnknown";
    inputDataTypeUnknown: FunctionInputDataTypeUnknown;
}
interface BlockInstallFunctionShapeError_inputDataTypeUnknownV2 {
    type: "inputDataTypeUnknownV2";
    inputDataTypeUnknownV2: FunctionInputDataTypeUnknownV2;
}
interface BlockInstallFunctionShapeError_inputExtraDataTypeUnknown {
    type: "inputExtraDataTypeUnknown";
    inputExtraDataTypeUnknown: FunctionExtraInputDataTypeUnknown;
}
interface BlockInstallFunctionShapeError_inputNamesDiffer {
    type: "inputNamesDiffer";
    inputNamesDiffer: FunctionInputNamesDiffer;
}
interface BlockInstallFunctionShapeError_inputNotFound {
    type: "inputNotFound";
    inputNotFound: FunctionInputNotFound;
}
interface BlockInstallFunctionShapeError_inputNotFoundV2 {
    type: "inputNotFoundV2";
    inputNotFoundV2: FunctionInputNotFoundV2;
}
interface BlockInstallFunctionShapeError_inputNotOptional {
    type: "inputNotOptional";
    inputNotOptional: FunctionInputNotOptional;
}
interface BlockInstallFunctionShapeError_inputNotOptionalV2 {
    type: "inputNotOptionalV2";
    inputNotOptionalV2: FunctionInputNotOptionalV2;
}
interface BlockInstallFunctionShapeError_outputDataTypeActionTypeReferencesUnsupported {
    type: "outputDataTypeActionTypeReferencesUnsupported";
    outputDataTypeActionTypeReferencesUnsupported: FunctionOutputDataTypeActionTypeReferencesUnsupported;
}
interface BlockInstallFunctionShapeError_outputDataTypeCustomTypeNotFound {
    type: "outputDataTypeCustomTypeNotFound";
    outputDataTypeCustomTypeNotFound: FunctionOutputDataTypeCustomTypeNotFound;
}
interface BlockInstallFunctionShapeError_outputDataTypeInterfaceTypeUnresolvable {
    type: "outputDataTypeInterfaceTypeUnresolvable";
    outputDataTypeInterfaceTypeUnresolvable: FunctionOutputDataTypeInterfaceTypeRidUnresolvable;
}
interface BlockInstallFunctionShapeError_outputDataTypeMarkingSubTypeUnknown {
    type: "outputDataTypeMarkingSubTypeUnknown";
    outputDataTypeMarkingSubTypeUnknown: FunctionOutputDataTypeMarkingSubTypeUnknown;
}
interface BlockInstallFunctionShapeError_outputDataTypeMismatch {
    type: "outputDataTypeMismatch";
    outputDataTypeMismatch: FunctionOutputDataTypeMismatch;
}
interface BlockInstallFunctionShapeError_outputDataTypeObjectTypeUnresolvable {
    type: "outputDataTypeObjectTypeUnresolvable";
    outputDataTypeObjectTypeUnresolvable: FunctionOutputDataTypeObjectTypeIdUnresolvable;
}
interface BlockInstallFunctionShapeError_outputDataTypeUnknown {
    type: "outputDataTypeUnknown";
    outputDataTypeUnknown: FunctionOutputDataTypeUnknown;
}
interface BlockInstallFunctionShapeError_outputTypeUnknown {
    type: "outputTypeUnknown";
    outputTypeUnknown: FunctionOutputTypeUnknown;
}
interface BlockInstallFunctionShapeError_outputTypeMismatch {
    type: "outputTypeMismatch";
    outputTypeMismatch: FunctionOutputTypeMismatch;
}
interface BlockInstallFunctionShapeError_unexpectedNonOptionalInput {
    type: "unexpectedNonOptionalInput";
    unexpectedNonOptionalInput: UnexpectedNonOptionalFunctionInput;
}
interface BlockInstallFunctionShapeError_unexpectedNonOptionalInputV2 {
    type: "unexpectedNonOptionalInputV2";
    unexpectedNonOptionalInputV2: UnexpectedNonOptionalFunctionInputV2;
}
type BlockInstallFunctionShapeError = BlockInstallFunctionShapeError_contractNotImplemented | BlockInstallFunctionShapeError_doesNotSatisfyContractExpression | BlockInstallFunctionShapeError_customTypeDataTypeActionTypeReferencesUnsupported | BlockInstallFunctionShapeError_customTypeDataTypeCustomTypeNotFound | BlockInstallFunctionShapeError_customTypeDataTypeInterfaceTypeUnresolvable | BlockInstallFunctionShapeError_customTypeDataTypeMarkingSubTypeUnknown | BlockInstallFunctionShapeError_customTypeDataTypeObjectTypeUnresolvable | BlockInstallFunctionShapeError_customTypeDataTypeUnknown | BlockInstallFunctionShapeError_dataTypeValueTypeUnresolvable | BlockInstallFunctionShapeError_dataTypeValueTypeUnresolvableV2 | BlockInstallFunctionShapeError_incompatibleContractSemverBlocking | BlockInstallFunctionShapeError_incompatibleContractSemverNonBlocking | BlockInstallFunctionShapeError_inputDataTypeActionTypeReferencesUnsupported | BlockInstallFunctionShapeError_inputDataTypeActionTypeReferencesUnsupportedV2 | BlockInstallFunctionShapeError_inputDataTypeCustomTypeNotFound | BlockInstallFunctionShapeError_inputDataTypeCustomTypeNotFoundV2 | BlockInstallFunctionShapeError_inputDataTypeInterfaceTypeUnresolvable | BlockInstallFunctionShapeError_inputDataTypeMarkingSubTypeUnknown | BlockInstallFunctionShapeError_inputDataTypeMarkingSubTypeUnknownV2 | BlockInstallFunctionShapeError_inputDataTypeMismatch | BlockInstallFunctionShapeError_inputDataTypeMismatchV2 | BlockInstallFunctionShapeError_inputDataTypeObjectTypeUnresolvable | BlockInstallFunctionShapeError_inputDataTypeObjectTypeUnresolvableV2 | BlockInstallFunctionShapeError_inputDataTypeUnknown | BlockInstallFunctionShapeError_inputDataTypeUnknownV2 | BlockInstallFunctionShapeError_inputExtraDataTypeUnknown | BlockInstallFunctionShapeError_inputNamesDiffer | BlockInstallFunctionShapeError_inputNotFound | BlockInstallFunctionShapeError_inputNotFoundV2 | BlockInstallFunctionShapeError_inputNotOptional | BlockInstallFunctionShapeError_inputNotOptionalV2 | BlockInstallFunctionShapeError_outputDataTypeActionTypeReferencesUnsupported | BlockInstallFunctionShapeError_outputDataTypeCustomTypeNotFound | BlockInstallFunctionShapeError_outputDataTypeInterfaceTypeUnresolvable | BlockInstallFunctionShapeError_outputDataTypeMarkingSubTypeUnknown | BlockInstallFunctionShapeError_outputDataTypeMismatch | BlockInstallFunctionShapeError_outputDataTypeObjectTypeUnresolvable | BlockInstallFunctionShapeError_outputDataTypeUnknown | BlockInstallFunctionShapeError_outputTypeUnknown | BlockInstallFunctionShapeError_outputTypeMismatch | BlockInstallFunctionShapeError_unexpectedNonOptionalInput | BlockInstallFunctionShapeError_unexpectedNonOptionalInputV2;
interface BlockInstallFunctionShapeErrorV2_shapeConversion {
    type: "shapeConversion";
    shapeConversion: FunctionShapeConversionError;
}
interface BlockInstallFunctionShapeErrorV2_incompatibleSignature {
    type: "incompatibleSignature";
    incompatibleSignature: FunctionShapeSignatureCompatibilityError;
}
type BlockInstallFunctionShapeErrorV2 = BlockInstallFunctionShapeErrorV2_shapeConversion | BlockInstallFunctionShapeErrorV2_incompatibleSignature;
/**
 * The ActionType referenced by the resolved input shape was not found.
 */
interface BlockInstallInputActionTypeNotFound {
    actionTypeRid: ActionTypeRid;
}
/**
 * There were one or more input dependency cycles detected in the input installation graph.
 */
interface BlockInstallInputDependencyCycles {
    cycles: Array<InputDependencyCycle>;
}
/**
 * Value type of the provided ResolvedParameterInputShape does not match the expected type.
 */
interface BlockInstallInputParameterTypeMismatch {
    actual: DataType;
    expected: DataType;
}
interface BlockInstallInputShapeNotSpecified_requiredInputShape {
    type: "requiredInputShape";
    requiredInputShape: Void;
}
interface BlockInstallInputShapeNotSpecified_usedByInputGroup {
    type: "usedByInputGroup";
    usedByInputGroup: BlockInstallInputShapeUsedByInputGroup;
}
type BlockInstallInputShapeNotSpecified = BlockInstallInputShapeNotSpecified_requiredInputShape | BlockInstallInputShapeNotSpecified_usedByInputGroup;
/**
 * The resolved input shape type is inconsistent with the unresolved shape type.
 */
interface BlockInstallInputShapeTypeMismatch {
    actual: InputShapeType;
    expected: InputShapeType;
}
interface BlockInstallInputShapeUsedByInputGroup {
    inputGroup: BlockSetInputGroupId;
}
/**
 * The InterfaceActionTypeConstraint does not include all the necessary parameter constraints.
 */
interface BlockInstallInterfaceActionTypeConstraintMissingParameterConstraints {
    interfaceActionTypeConstraintRid: InterfaceActionTypeConstraintRid;
    missingInterfaceParameterConstraintReferences: Array<InterfaceParameterConstraintReference>;
}
interface BlockInstallInterfaceActionTypeConstraintNotFound {
    interfaceActionTypeConstraintRid: InterfaceActionTypeConstraintRid;
    interfaceTypeRid: InterfaceTypeRid;
}
interface BlockInstallInterfaceActionTypeConstraintShapeError_interfaceTypeReferenceUnresolvable {
    type: "interfaceTypeReferenceUnresolvable";
    interfaceTypeReferenceUnresolvable: InterfaceTypeReferenceUnresolvable;
}
interface BlockInstallInterfaceActionTypeConstraintShapeError_interfaceTypeReferenceMismatch {
    type: "interfaceTypeReferenceMismatch";
    interfaceTypeReferenceMismatch: ResolvedInterfaceTypeReferenceMismatch;
}
interface BlockInstallInterfaceActionTypeConstraintShapeError_interfaceActionTypeConstraintRequiredMismatch {
    type: "interfaceActionTypeConstraintRequiredMismatch";
    interfaceActionTypeConstraintRequiredMismatch: InterfaceActionTypeConstraintRequiredMismatch;
}
type BlockInstallInterfaceActionTypeConstraintShapeError = BlockInstallInterfaceActionTypeConstraintShapeError_interfaceTypeReferenceUnresolvable | BlockInstallInterfaceActionTypeConstraintShapeError_interfaceTypeReferenceMismatch | BlockInstallInterfaceActionTypeConstraintShapeError_interfaceActionTypeConstraintRequiredMismatch;
/**
 * The InterfaceLinkType referenced by the resolved shape was not found.
 */
interface BlockInstallInterfaceLinkTypeNotFound {
    interfaceLinkTypeRid: InterfaceLinkTypeRid;
    interfaceTypeRid: InterfaceTypeRid;
}
interface BlockInstallInterfaceLinkTypeShapeError_interfaceTypeReferenceUnresolvable {
    type: "interfaceTypeReferenceUnresolvable";
    interfaceTypeReferenceUnresolvable: InterfaceTypeReferenceUnresolvable;
}
interface BlockInstallInterfaceLinkTypeShapeError_interfaceTypeReferenceMismatch {
    type: "interfaceTypeReferenceMismatch";
    interfaceTypeReferenceMismatch: ResolvedInterfaceTypeReferenceMismatch;
}
interface BlockInstallInterfaceLinkTypeShapeError_linkedInterfaceTypeReferenceUnresolvable {
    type: "linkedInterfaceTypeReferenceUnresolvable";
    linkedInterfaceTypeReferenceUnresolvable: LinkedInterfaceTypeReferenceUnresolvable;
}
interface BlockInstallInterfaceLinkTypeShapeError_linkedInterfaceTypeReferenceMismatch {
    type: "linkedInterfaceTypeReferenceMismatch";
    linkedInterfaceTypeReferenceMismatch: LinkedInterfaceTypeReferenceMismatch;
}
interface BlockInstallInterfaceLinkTypeShapeError_expectedLinkedObjectButWasInterface {
    type: "expectedLinkedObjectButWasInterface";
    expectedLinkedObjectButWasInterface: ExpectedLinkedObjectButWasInterface;
}
interface BlockInstallInterfaceLinkTypeShapeError_linkedObjectTypeReferenceUnresolvable {
    type: "linkedObjectTypeReferenceUnresolvable";
    linkedObjectTypeReferenceUnresolvable: LinkedObjectTypeReferenceUnresolvable;
}
interface BlockInstallInterfaceLinkTypeShapeError_linkedObjectTypeReferenceMismatch {
    type: "linkedObjectTypeReferenceMismatch";
    linkedObjectTypeReferenceMismatch: LinkedObjectTypeReferenceMismatch;
}
interface BlockInstallInterfaceLinkTypeShapeError_expectedLinkedInterfaceButWasObject {
    type: "expectedLinkedInterfaceButWasObject";
    expectedLinkedInterfaceButWasObject: ExpectedLinkedInterfaceButWasObject;
}
interface BlockInstallInterfaceLinkTypeShapeError_interfaceLinkTypeCardinalityMismatch {
    type: "interfaceLinkTypeCardinalityMismatch";
    interfaceLinkTypeCardinalityMismatch: InterfaceLinkTypeCardinalityMismatch;
}
interface BlockInstallInterfaceLinkTypeShapeError_interfaceLinkTypeRequiredMismatch {
    type: "interfaceLinkTypeRequiredMismatch";
    interfaceLinkTypeRequiredMismatch: InterfaceLinkTypeRequiredMismatch;
}
type BlockInstallInterfaceLinkTypeShapeError = BlockInstallInterfaceLinkTypeShapeError_interfaceTypeReferenceUnresolvable | BlockInstallInterfaceLinkTypeShapeError_interfaceTypeReferenceMismatch | BlockInstallInterfaceLinkTypeShapeError_linkedInterfaceTypeReferenceUnresolvable | BlockInstallInterfaceLinkTypeShapeError_linkedInterfaceTypeReferenceMismatch | BlockInstallInterfaceLinkTypeShapeError_expectedLinkedObjectButWasInterface | BlockInstallInterfaceLinkTypeShapeError_linkedObjectTypeReferenceUnresolvable | BlockInstallInterfaceLinkTypeShapeError_linkedObjectTypeReferenceMismatch | BlockInstallInterfaceLinkTypeShapeError_expectedLinkedInterfaceButWasObject | BlockInstallInterfaceLinkTypeShapeError_interfaceLinkTypeCardinalityMismatch | BlockInstallInterfaceLinkTypeShapeError_interfaceLinkTypeRequiredMismatch;
interface BlockInstallInterfaceParameterConstraintNotFound {
    interfaceActionTypeConstraintRid: InterfaceActionTypeConstraintRid;
    interfaceParameterConstraintRid: InterfaceParameterConstraintRid;
}
interface BlockInstallInterfaceParameterConstraintShapeError_actionTypeConstraintReferenceUnresolvable {
    type: "actionTypeConstraintReferenceUnresolvable";
    actionTypeConstraintReferenceUnresolvable: InterfaceActionTypeConstraintReferenceUnresolvable;
}
interface BlockInstallInterfaceParameterConstraintShapeError_actionTypeConstraintReferenceMismatch {
    type: "actionTypeConstraintReferenceMismatch";
    actionTypeConstraintReferenceMismatch: ResolvedInterfaceActionTypeConstraintReferenceMismatch;
}
interface BlockInstallInterfaceParameterConstraintShapeError_interfaceParameterConstraintRequiredMismatch {
    type: "interfaceParameterConstraintRequiredMismatch";
    interfaceParameterConstraintRequiredMismatch: InterfaceParameterConstraintRequiredMismatch;
}
interface BlockInstallInterfaceParameterConstraintShapeError_interfaceParameterConstraintTypeMismatch {
    type: "interfaceParameterConstraintTypeMismatch";
    interfaceParameterConstraintTypeMismatch: InterfaceParameterConstraintTypeMismatch;
}
type BlockInstallInterfaceParameterConstraintShapeError = BlockInstallInterfaceParameterConstraintShapeError_actionTypeConstraintReferenceUnresolvable | BlockInstallInterfaceParameterConstraintShapeError_actionTypeConstraintReferenceMismatch | BlockInstallInterfaceParameterConstraintShapeError_interfaceParameterConstraintRequiredMismatch | BlockInstallInterfaceParameterConstraintShapeError_interfaceParameterConstraintTypeMismatch;
/**
 * The InterfacePropertyType referenced by the resolved shape was not found.
 */
interface BlockInstallInterfacePropertyTypeNotFound {
    interfacePropertyTypeRid: InterfacePropertyTypeRid;
    interfaceTypeRid: InterfaceTypeRid;
}
interface BlockInstallInterfacePropertyTypeShapeError_interfaceTypeReferenceUnresolvable {
    type: "interfaceTypeReferenceUnresolvable";
    interfaceTypeReferenceUnresolvable: InterfaceTypeReferenceUnresolvable;
}
interface BlockInstallInterfacePropertyTypeShapeError_interfaceTypeReferenceMismatch {
    type: "interfaceTypeReferenceMismatch";
    interfaceTypeReferenceMismatch: ResolvedInterfaceTypeReferenceMismatch;
}
interface BlockInstallInterfacePropertyTypeShapeError_interfacePropertyTypeRequireImplementationMismatch {
    type: "interfacePropertyTypeRequireImplementationMismatch";
    interfacePropertyTypeRequireImplementationMismatch: InterfacePropertyTypeRequireImplementationMismatch;
}
interface BlockInstallInterfacePropertyTypeShapeError_sharedPropertyTypeReferenceMismatch {
    type: "sharedPropertyTypeReferenceMismatch";
    sharedPropertyTypeReferenceMismatch: InterfacePropertySharedPropertyTypeReferenceMismatch;
}
interface BlockInstallInterfacePropertyTypeShapeError_typeMismatch {
    type: "typeMismatch";
    typeMismatch: PropertyTypeMismatch;
}
interface BlockInstallInterfacePropertyTypeShapeError_typeUnknown {
    type: "typeUnknown";
    typeUnknown: PropertyTypeUnknown;
}
interface BlockInstallInterfacePropertyTypeShapeError_typeUnsupported {
    type: "typeUnsupported";
    typeUnsupported: string;
}
interface BlockInstallInterfacePropertyTypeShapeError_nestedTypeUnknown {
    type: "nestedTypeUnknown";
    nestedTypeUnknown: PropertyTypeUnknown;
}
interface BlockInstallInterfacePropertyTypeShapeError_nestedArraysUnsupported {
    type: "nestedArraysUnsupported";
    nestedArraysUnsupported: Void;
}
interface BlockInstallInterfacePropertyTypeShapeError_plainTextTypeUnsupported {
    type: "plainTextTypeUnsupported";
    plainTextTypeUnsupported: PlainTextTypeUnsupported;
}
interface BlockInstallInterfacePropertyTypeShapeError_structFieldTypeUnsupported {
    type: "structFieldTypeUnsupported";
    structFieldTypeUnsupported: StructFieldTypeUnsupported;
}
type BlockInstallInterfacePropertyTypeShapeError = BlockInstallInterfacePropertyTypeShapeError_interfaceTypeReferenceUnresolvable | BlockInstallInterfacePropertyTypeShapeError_interfaceTypeReferenceMismatch | BlockInstallInterfacePropertyTypeShapeError_interfacePropertyTypeRequireImplementationMismatch | BlockInstallInterfacePropertyTypeShapeError_sharedPropertyTypeReferenceMismatch | BlockInstallInterfacePropertyTypeShapeError_typeMismatch | BlockInstallInterfacePropertyTypeShapeError_typeUnknown | BlockInstallInterfacePropertyTypeShapeError_typeUnsupported | BlockInstallInterfacePropertyTypeShapeError_nestedTypeUnknown | BlockInstallInterfacePropertyTypeShapeError_nestedArraysUnsupported | BlockInstallInterfacePropertyTypeShapeError_plainTextTypeUnsupported | BlockInstallInterfacePropertyTypeShapeError_structFieldTypeUnsupported;
/**
 * The InterfaceType does not include all the necessary action type constraints.
 */
interface BlockInstallInterfaceTypeMissingActionTypeConstraints {
    interfaceTypeRid: InterfaceTypeRid;
    missingInterfaceActionTypeConstraintReferences: Array<InterfaceActionTypeConstraintReference>;
}
/**
 * The InterfaceType does not include all the necessary extended interfaces.
 */
interface BlockInstallInterfaceTypeMissingExtendedInterfaces {
    interfaceTypeRid: InterfaceTypeRid;
    missingExtendedInterfaceTypeReferences: Array<InterfaceTypeReference>;
}
/**
 * The InterfaceType does not include all the necessary links
 */
interface BlockInstallInterfaceTypeMissingLinks {
    interfaceTypeRid: InterfaceTypeRid;
    missingInterfaceLinkTypeReferences: Array<InterfaceLinkTypeReference>;
}
/**
 * The InterfaceType does not include all the necessary properties
 */
interface BlockInstallInterfaceTypeMissingProperties {
    interfaceTypeRid: InterfaceTypeRid;
    missingInterfacePropertyTypeReferences: Array<InterfacePropertyTypeReference>;
    missingSharedPropertyTypeReferences: Array<SharedPropertyTypeReference>;
}
/**
 * The InterfaceType referenced by the resolved shape was not found.
 */
interface BlockInstallInterfaceTypeNotFound {
    interfaceTypeRid: InterfaceTypeRid;
}
/**
 * The LinkType referenced by the resolved shape was not found.
 */
interface BlockInstallLinkTypeNotFound {
    linkTypeId: LinkTypeId;
    linkTypeRid: LinkTypeRid;
}
interface BlockInstallLinkTypeShapeError_unexpectedManyToManyLink {
    type: "unexpectedManyToManyLink";
    unexpectedManyToManyLink: Void;
}
interface BlockInstallLinkTypeShapeError_unexpectedOneToManyLink {
    type: "unexpectedOneToManyLink";
    unexpectedOneToManyLink: Void;
}
interface BlockInstallLinkTypeShapeError_unexpectedLink {
    type: "unexpectedLink";
    unexpectedLink: LinkTypeUnexpected;
}
interface BlockInstallLinkTypeShapeError_unexpectedResolvedManyToManyLinkObjectTypes {
    type: "unexpectedResolvedManyToManyLinkObjectTypes";
    unexpectedResolvedManyToManyLinkObjectTypes: Void;
}
interface BlockInstallLinkTypeShapeError_unexpectedResolvedOneToManyLinkObjectTypes {
    type: "unexpectedResolvedOneToManyLinkObjectTypes";
    unexpectedResolvedOneToManyLinkObjectTypes: Void;
}
interface BlockInstallLinkTypeShapeError_unexpectedLinkedOntologyTypes {
    type: "unexpectedLinkedOntologyTypes";
    unexpectedLinkedOntologyTypes: LinkTypeUnexpected;
}
interface BlockInstallLinkTypeShapeError_resolvedLinkedObjectTypesUnknown {
    type: "resolvedLinkedObjectTypesUnknown";
    resolvedLinkedObjectTypesUnknown: ResolvedLinkedObjectTypesUnknown;
}
interface BlockInstallLinkTypeShapeError_linkTypeUnknown {
    type: "linkTypeUnknown";
    linkTypeUnknown: LinkTypeUnknown;
}
interface BlockInstallLinkTypeShapeError_intermediaryLinkObjectTypeUnresolvable {
    type: "intermediaryLinkObjectTypeUnresolvable";
    intermediaryLinkObjectTypeUnresolvable: IntermediaryLinkObjectTypeReferenceUnresolvable;
}
interface BlockInstallLinkTypeShapeError_intermediaryLinkObjectTypeMismatch {
    type: "intermediaryLinkObjectTypeMismatch";
    intermediaryLinkObjectTypeMismatch: IntermediaryLinkObjectTypeMismatch;
}
interface BlockInstallLinkTypeShapeError_intermediaryLinkLinkTypeUnresolvable {
    type: "intermediaryLinkLinkTypeUnresolvable";
    intermediaryLinkLinkTypeUnresolvable: IntermediaryLinkLinkTypeReferenceUnresolvable;
}
interface BlockInstallLinkTypeShapeError_intermediaryLinkLinkTypeMismatch {
    type: "intermediaryLinkLinkTypeMismatch";
    intermediaryLinkLinkTypeMismatch: IntermediaryLinkLinkTypeReferenceMismatch;
}
interface BlockInstallLinkTypeShapeError_manyToManyLinkObjectTypeAUnresolvable {
    type: "manyToManyLinkObjectTypeAUnresolvable";
    manyToManyLinkObjectTypeAUnresolvable: ObjectTypeReferenceUnresolvable;
}
interface BlockInstallLinkTypeShapeError_manyToManyLinkObjectTypeAMismatch {
    type: "manyToManyLinkObjectTypeAMismatch";
    manyToManyLinkObjectTypeAMismatch: ResolvedObjectTypeReferenceMismatch;
}
interface BlockInstallLinkTypeShapeError_manyToManyLinkObjectTypeBUnresolvable {
    type: "manyToManyLinkObjectTypeBUnresolvable";
    manyToManyLinkObjectTypeBUnresolvable: ObjectTypeReferenceUnresolvable;
}
interface BlockInstallLinkTypeShapeError_manyToManyLinkObjectTypeBMismatch {
    type: "manyToManyLinkObjectTypeBMismatch";
    manyToManyLinkObjectTypeBMismatch: ResolvedObjectTypeReferenceMismatch;
}
interface BlockInstallLinkTypeShapeError_oneToManyLinkOneSideObjectTypeUnresolvable {
    type: "oneToManyLinkOneSideObjectTypeUnresolvable";
    oneToManyLinkOneSideObjectTypeUnresolvable: ObjectTypeReferenceUnresolvable;
}
interface BlockInstallLinkTypeShapeError_oneToManyLinkOneSideObjectTypeMismatch {
    type: "oneToManyLinkOneSideObjectTypeMismatch";
    oneToManyLinkOneSideObjectTypeMismatch: ResolvedObjectTypeReferenceMismatch;
}
interface BlockInstallLinkTypeShapeError_oneToManyLinkManySideObjectTypeUnresolvable {
    type: "oneToManyLinkManySideObjectTypeUnresolvable";
    oneToManyLinkManySideObjectTypeUnresolvable: ObjectTypeReferenceUnresolvable;
}
interface BlockInstallLinkTypeShapeError_oneToManyLinkManySideObjectTypeMismatch {
    type: "oneToManyLinkManySideObjectTypeMismatch";
    oneToManyLinkManySideObjectTypeMismatch: ResolvedObjectTypeReferenceMismatch;
}
interface BlockInstallLinkTypeShapeError_resolvedManyToManyLinkObjectTypesInconsistent {
    type: "resolvedManyToManyLinkObjectTypesInconsistent";
    resolvedManyToManyLinkObjectTypesInconsistent: ResolvedManyToManyLinkObjectTypesInconsistent;
}
interface BlockInstallLinkTypeShapeError_resolvedOneToManyLinkObjectTypesInconsistent {
    type: "resolvedOneToManyLinkObjectTypesInconsistent";
    resolvedOneToManyLinkObjectTypesInconsistent: ResolvedOneToManyLinkObjectTypesInconsistent;
}
interface BlockInstallLinkTypeShapeError_resolvedIntermediaryLinkOntologyTypesInconsistent {
    type: "resolvedIntermediaryLinkOntologyTypesInconsistent";
    resolvedIntermediaryLinkOntologyTypesInconsistent: ResolvedIntermediaryLinkOntologyTypesInconsistent;
}
interface BlockInstallLinkTypeShapeError_editsSupportIncompatible {
    type: "editsSupportIncompatible";
    editsSupportIncompatible: EditsSupportIncompatible;
}
interface BlockInstallLinkTypeShapeError_backendIncompatible {
    type: "backendIncompatible";
    backendIncompatible: ObjectsBackendIncompatible;
}
interface BlockInstallLinkTypeShapeError_objectsBackendUnknown {
    type: "objectsBackendUnknown";
    objectsBackendUnknown: ObjectsBackendUnknown;
}
interface BlockInstallLinkTypeShapeError_outputBackendMismatch {
    type: "outputBackendMismatch";
    outputBackendMismatch: OutputObjectsBackendMismatch;
}
interface BlockInstallLinkTypeShapeError_outputEditsSupportMismatch {
    type: "outputEditsSupportMismatch";
    outputEditsSupportMismatch: OutputEditsSupportMismatch;
}
type BlockInstallLinkTypeShapeError = BlockInstallLinkTypeShapeError_unexpectedManyToManyLink | BlockInstallLinkTypeShapeError_unexpectedOneToManyLink | BlockInstallLinkTypeShapeError_unexpectedLink | BlockInstallLinkTypeShapeError_unexpectedResolvedManyToManyLinkObjectTypes | BlockInstallLinkTypeShapeError_unexpectedResolvedOneToManyLinkObjectTypes | BlockInstallLinkTypeShapeError_unexpectedLinkedOntologyTypes | BlockInstallLinkTypeShapeError_resolvedLinkedObjectTypesUnknown | BlockInstallLinkTypeShapeError_linkTypeUnknown | BlockInstallLinkTypeShapeError_intermediaryLinkObjectTypeUnresolvable | BlockInstallLinkTypeShapeError_intermediaryLinkObjectTypeMismatch | BlockInstallLinkTypeShapeError_intermediaryLinkLinkTypeUnresolvable | BlockInstallLinkTypeShapeError_intermediaryLinkLinkTypeMismatch | BlockInstallLinkTypeShapeError_manyToManyLinkObjectTypeAUnresolvable | BlockInstallLinkTypeShapeError_manyToManyLinkObjectTypeAMismatch | BlockInstallLinkTypeShapeError_manyToManyLinkObjectTypeBUnresolvable | BlockInstallLinkTypeShapeError_manyToManyLinkObjectTypeBMismatch | BlockInstallLinkTypeShapeError_oneToManyLinkOneSideObjectTypeUnresolvable | BlockInstallLinkTypeShapeError_oneToManyLinkOneSideObjectTypeMismatch | BlockInstallLinkTypeShapeError_oneToManyLinkManySideObjectTypeUnresolvable | BlockInstallLinkTypeShapeError_oneToManyLinkManySideObjectTypeMismatch | BlockInstallLinkTypeShapeError_resolvedManyToManyLinkObjectTypesInconsistent | BlockInstallLinkTypeShapeError_resolvedOneToManyLinkObjectTypesInconsistent | BlockInstallLinkTypeShapeError_resolvedIntermediaryLinkOntologyTypesInconsistent | BlockInstallLinkTypeShapeError_editsSupportIncompatible | BlockInstallLinkTypeShapeError_backendIncompatible | BlockInstallLinkTypeShapeError_objectsBackendUnknown | BlockInstallLinkTypeShapeError_outputBackendMismatch | BlockInstallLinkTypeShapeError_outputEditsSupportMismatch;
/**
 * The location to install a block into. Additional targets might be added to this object in the future.
 * Used by `MarketplaceBlockInstallerService`. This is different from `InstallLocation`, which is used by the
 * `BlockInstallationServiceV2.installBlocks` and represents the location to install *a set* of blocks into.
 */
interface BlockInstallLocation {
    compass: CompassInstallLocation;
    ontology?: OntologyInstallLocation | null | undefined;
}
/**
 * An entity was selected to be used as input but either the resource itself or some associated
 * resource (for example branch rid for a dataset input) does not satisfy security constraints set on
 * the Marketplace project for the installation. The input needs to be imported as a reference into the
 * installation project manually using the Compass UI before Marketplace can use it as an input.
 */
interface BlockInstallLocationClassificationConstraintsNotSatisfied {
    constraintsSatisfiedForResources: Record<string, boolean>;
    folderRid: CompassFolderRid;
    resourceIdentifier: string;
}
/**
 * The connection type declared on the shape does not match the connection type retrieved from the source.
 */
interface BlockInstallMagritteConnectionTypeMismatchError {
    actualMagritteConnectionType: MagritteConnectionType;
    expectedMagritteConnectionType: MagritteConnectionType;
}
/**
 * The connection type is not supported by Marketplace.
 */
interface BlockInstallMagritteConnectionTypeUnsupported {
    connectionType: MagritteConnectionType;
}
/**
 * The selected Magritte Source API name does not match the required API name.
 */
interface BlockInstallMagritteSourceApiNameMismatch {
    actual?: MagritteApiName | null | undefined;
    expected: MagritteApiName;
    severity: ErrorSeverity;
}
/**
 * The selected Magritte Source is missing required secrets required by the shape.
 */
interface BlockInstallMagritteSourceMissingRequiredSecrets {
    missingRequiredSecrets: Array<MagritteSecretName>;
    severity: ErrorSeverity;
}
/**
 * The selected Magritte Source is missing required usage restrictions required by the shape.
 */
interface BlockInstallMagritteSourceMissingRequiredUsageRestrictions {
    missingRequiredUsageRestrictions: MagritteSourceUsageRestrictionName;
    severity: ErrorSeverity;
}
/**
 * The provided source rid in ResolvedMagritteSourceInputShape is not found in Magritte.
 */
interface BlockInstallMagritteSourceNotFound {
    magritteSourceRid: MagritteSourceRid;
}
/**
 * Source type of the provided ResolvedMagritteSourceInputShape does not match the expected type.
 */
interface BlockInstallMagritteSourceTypeMismatch {
    actual: MagritteSourceType;
    expected: MagritteSourceType;
}
/**
 * The media set path policy on the input shape cannot be matched with the path policy on the resolved shape.
 */
interface BlockInstallMediaSetIncompatiblePathPolicy {
    requiredPathPolicy: PathPolicy;
    resolvedPathPolicy: PathPolicy;
}
/**
 * The media set schema on the input shape is incompatible with the media set schema on the resolved shape.
 */
interface BlockInstallMediaSetIncompatibleSchema {
    expectedMediaSetSchema: MediaSchemaType;
    resolvedMediaSetSchema: MediaSchemaType;
}
/**
 * The media set schema V2 on the input shape is incompatible with the media set schema V2 on the resolved shape.
 */
interface BlockInstallMediaSetIncompatibleSchemaV2 {
    expectedMediaSetSchema: MediaSchemaTypeV2;
    resolvedMediaSetSchema: MediaSchemaTypeV2;
}
/**
 * The media set transaction policy on the input shape cannot be matched with the transaction policy on the
 * resolved shape.
 */
interface BlockInstallMediaSetIncompatibleTransactionPolicy {
    requiredTransactionPolicy: MediaSetTransactionPolicy;
    resolvedTransactionPolicy: MediaSetTransactionPolicy;
}
/**
 * A media set was provided as input, but the files datasource input shape only supports datasets.
 * Opposite of `FilesDatasourceTypeNotSupported`.
 */
interface BlockInstallMediaSetNotSupported {
}
interface BlockInstallModelShapeError_serviceMismatch {
    type: "serviceMismatch";
    serviceMismatch: ModelResourceShapeServiceMismatch;
}
interface BlockInstallModelShapeError_ridTypeMismatch {
    type: "ridTypeMismatch";
    ridTypeMismatch: ModelResourceTypeMismatch;
}
interface BlockInstallModelShapeError_modelTypeMismatch {
    type: "modelTypeMismatch";
    modelTypeMismatch: ModelTypeMismatch;
}
interface BlockInstallModelShapeError_modelTypeMismatchV2 {
    type: "modelTypeMismatchV2";
    modelTypeMismatchV2: ModelTypeMismatchV2;
}
interface BlockInstallModelShapeError_modelTypeMismatchV3 {
    type: "modelTypeMismatchV3";
    modelTypeMismatchV3: ModelTypeMismatchV3;
}
type BlockInstallModelShapeError = BlockInstallModelShapeError_serviceMismatch | BlockInstallModelShapeError_ridTypeMismatch | BlockInstallModelShapeError_modelTypeMismatch | BlockInstallModelShapeError_modelTypeMismatchV2 | BlockInstallModelShapeError_modelTypeMismatchV3;
/**
 * The Notepad template referenced by the resolved shape was not found.
 */
interface BlockInstallNotepadTemplateNotFound {
    notepadTemplateRid: NotepadTemplateRid;
    notepadTemplateVersion?: NotepadTemplateVersion | null | undefined;
}
/**
 * The Notepad template parameter referenced by the resolved shape was not found.
 */
interface BlockInstallNotepadTemplateParameterNotFound {
    notepadTemplateParameterId: NotepadTemplateParameterId;
    notepadTemplateRid: NotepadTemplateRid;
}
interface BlockInstallNotepadTemplateParameterShapeError_parameterTypeMismatch {
    type: "parameterTypeMismatch";
    parameterTypeMismatch: NotepadTemplateParameterTypeMismatch;
}
type BlockInstallNotepadTemplateParameterShapeError = BlockInstallNotepadTemplateParameterShapeError_parameterTypeMismatch;
/**
 * The ObjectType referenced by a resolved object view shape was not found.
 */
interface BlockInstallObjectTypeForObjectViewNotFound {
    objectTypeRid: ObjectTypeRid;
}
/**
 * The ObjectType referenced by the resolved shape was not found.
 */
interface BlockInstallObjectTypeNotFound {
    objectTypeId: ObjectTypeId;
    objectTypeRid: ObjectTypeRid;
}
interface BlockInstallObjectTypeShapeError_backendIncompatible {
    type: "backendIncompatible";
    backendIncompatible: ObjectsBackendIncompatible;
}
interface BlockInstallObjectTypeShapeError_editsSupportIncompatible {
    type: "editsSupportIncompatible";
    editsSupportIncompatible: EditsSupportIncompatible;
}
interface BlockInstallObjectTypeShapeError_objectsBackendUnknown {
    type: "objectsBackendUnknown";
    objectsBackendUnknown: ObjectsBackendUnknown;
}
interface BlockInstallObjectTypeShapeError_outputBackendMismatch {
    type: "outputBackendMismatch";
    outputBackendMismatch: OutputObjectsBackendMismatch;
}
interface BlockInstallObjectTypeShapeError_outputEditsSupportMismatch {
    type: "outputEditsSupportMismatch";
    outputEditsSupportMismatch: OutputEditsSupportMismatch;
}
type BlockInstallObjectTypeShapeError = BlockInstallObjectTypeShapeError_backendIncompatible | BlockInstallObjectTypeShapeError_editsSupportIncompatible | BlockInstallObjectTypeShapeError_objectsBackendUnknown | BlockInstallObjectTypeShapeError_outputBackendMismatch | BlockInstallObjectTypeShapeError_outputEditsSupportMismatch;
/**
 * The resolved output shape type is inconsistent with the unresolved shape type.
 */
interface BlockInstallOutputShapeTypeMismatch {
    actual: OutputShapeType;
    expected: OutputShapeType;
}
interface BlockInstallPrefixShapeError_prefixInvalid {
    type: "prefixInvalid";
    prefixInvalid: Void;
}
interface BlockInstallPrefixShapeError_inconsistentPrefix {
    type: "inconsistentPrefix";
    inconsistentPrefix: Void;
}
/**
 * Errors specific to InstallPrefixShape(s).
 */
type BlockInstallPrefixShapeError = BlockInstallPrefixShapeError_prefixInvalid | BlockInstallPrefixShapeError_inconsistentPrefix;
/**
 * The PropertyType referenced by the resolved shape was not found.
 */
interface BlockInstallPropertyTypeNotFound {
    objectTypeId: ObjectTypeId;
    objectTypeRid: ObjectTypeRid;
    propertyTypeId: PropertyTypeId;
    propertyTypeRid: PropertyTypeRid;
}
interface BlockInstallPropertyTypeShapeError_typeMismatch {
    type: "typeMismatch";
    typeMismatch: PropertyTypeMismatch;
}
interface BlockInstallPropertyTypeShapeError_vectorTypeMismatchNonBlocking {
    type: "vectorTypeMismatchNonBlocking";
    vectorTypeMismatchNonBlocking: PropertyTypeMismatch;
}
interface BlockInstallPropertyTypeShapeError_typeUnknown {
    type: "typeUnknown";
    typeUnknown: PropertyTypeUnknown;
}
interface BlockInstallPropertyTypeShapeError_typeUnsupported {
    type: "typeUnsupported";
    typeUnsupported: string;
}
interface BlockInstallPropertyTypeShapeError_nestedTypeUnknown {
    type: "nestedTypeUnknown";
    nestedTypeUnknown: PropertyTypeUnknown;
}
interface BlockInstallPropertyTypeShapeError_nestedArraysUnsupported {
    type: "nestedArraysUnsupported";
    nestedArraysUnsupported: Void;
}
interface BlockInstallPropertyTypeShapeError_plainTextTypeUnsupported {
    type: "plainTextTypeUnsupported";
    plainTextTypeUnsupported: PlainTextTypeUnsupported;
}
interface BlockInstallPropertyTypeShapeError_structFieldTypeUnsupported {
    type: "structFieldTypeUnsupported";
    structFieldTypeUnsupported: StructFieldTypeUnsupported;
}
interface BlockInstallPropertyTypeShapeError_objectTypeReferenceMismatch {
    type: "objectTypeReferenceMismatch";
    objectTypeReferenceMismatch: ResolvedObjectTypeReferenceMismatch;
}
interface BlockInstallPropertyTypeShapeError_objectTypeReferenceUnresolvable {
    type: "objectTypeReferenceUnresolvable";
    objectTypeReferenceUnresolvable: ObjectTypeReferenceUnresolvable;
}
interface BlockInstallPropertyTypeShapeError_inlineActionTypeMissing {
    type: "inlineActionTypeMissing";
    inlineActionTypeMissing: InlineActionTypeMissing;
}
interface BlockInstallPropertyTypeShapeError_inlineActionTypeReferenceMismatch {
    type: "inlineActionTypeReferenceMismatch";
    inlineActionTypeReferenceMismatch: ResolvedActionTypeReferenceMismatch;
}
interface BlockInstallPropertyTypeShapeError_inlineActionTypeReferenceUnresolvable {
    type: "inlineActionTypeReferenceUnresolvable";
    inlineActionTypeReferenceUnresolvable: ActionTypeReferenceUnresolvable;
}
interface BlockInstallPropertyTypeShapeError_sharedPropertyTypeMissing {
    type: "sharedPropertyTypeMissing";
    sharedPropertyTypeMissing: SharedPropertyTypeMissing;
}
interface BlockInstallPropertyTypeShapeError_sharedPropertyTypeReferenceMismatch {
    type: "sharedPropertyTypeReferenceMismatch";
    sharedPropertyTypeReferenceMismatch: ResolvedSharedPropertyTypeReferenceMismatch;
}
interface BlockInstallPropertyTypeShapeError_sharedPropertyTypeReferenceUnresolvable {
    type: "sharedPropertyTypeReferenceUnresolvable";
    sharedPropertyTypeReferenceUnresolvable: SharedPropertyTypeReferenceUnresolvable;
}
type BlockInstallPropertyTypeShapeError = BlockInstallPropertyTypeShapeError_typeMismatch | BlockInstallPropertyTypeShapeError_vectorTypeMismatchNonBlocking | BlockInstallPropertyTypeShapeError_typeUnknown | BlockInstallPropertyTypeShapeError_typeUnsupported | BlockInstallPropertyTypeShapeError_nestedTypeUnknown | BlockInstallPropertyTypeShapeError_nestedArraysUnsupported | BlockInstallPropertyTypeShapeError_plainTextTypeUnsupported | BlockInstallPropertyTypeShapeError_structFieldTypeUnsupported | BlockInstallPropertyTypeShapeError_objectTypeReferenceMismatch | BlockInstallPropertyTypeShapeError_objectTypeReferenceUnresolvable | BlockInstallPropertyTypeShapeError_inlineActionTypeMissing | BlockInstallPropertyTypeShapeError_inlineActionTypeReferenceMismatch | BlockInstallPropertyTypeShapeError_inlineActionTypeReferenceUnresolvable | BlockInstallPropertyTypeShapeError_sharedPropertyTypeMissing | BlockInstallPropertyTypeShapeError_sharedPropertyTypeReferenceMismatch | BlockInstallPropertyTypeShapeError_sharedPropertyTypeReferenceUnresolvable;
/**
 * Block specific installation generic error wrapping response ReconcileBlockInstallationResponseError from reconciliation.
 */
interface BlockInstallReconcileError {
    errorCode: string;
}
/**
 * The resolved output shape is a compass resource and is not inside the expected target project,
 * because it may have been moved manually. This is validated against both non-trashed and trashed resources.
 */
interface BlockInstallResourceNotChildOfTargetCompassFolder {
    rid: string;
}
/**
 * The resource referenced by the resolved shape was not found. This could happen if the
 * resource doesn't exist or is not visible to the user.
 */
interface BlockInstallResourceNotFound {
    rid: string;
}
/**
 * The SharedPropertyType referenced by the resolved shape was not found.
 */
interface BlockInstallSharedPropertyTypeNotFound {
    sharedPropertyTypeRid: SharedPropertyTypeRid;
}
interface BlockInstallSharedPropertyTypeShapeError_typeMismatch {
    type: "typeMismatch";
    typeMismatch: PropertyTypeMismatch;
}
interface BlockInstallSharedPropertyTypeShapeError_typeUnknown {
    type: "typeUnknown";
    typeUnknown: PropertyTypeUnknown;
}
interface BlockInstallSharedPropertyTypeShapeError_typeUnsupported {
    type: "typeUnsupported";
    typeUnsupported: string;
}
interface BlockInstallSharedPropertyTypeShapeError_nestedTypeUnknown {
    type: "nestedTypeUnknown";
    nestedTypeUnknown: PropertyTypeUnknown;
}
interface BlockInstallSharedPropertyTypeShapeError_nestedArraysUnsupported {
    type: "nestedArraysUnsupported";
    nestedArraysUnsupported: Void;
}
interface BlockInstallSharedPropertyTypeShapeError_plainTextTypeUnsupported {
    type: "plainTextTypeUnsupported";
    plainTextTypeUnsupported: PlainTextTypeUnsupported;
}
interface BlockInstallSharedPropertyTypeShapeError_structFieldTypeUnsupported {
    type: "structFieldTypeUnsupported";
    structFieldTypeUnsupported: StructFieldTypeUnsupported;
}
type BlockInstallSharedPropertyTypeShapeError = BlockInstallSharedPropertyTypeShapeError_typeMismatch | BlockInstallSharedPropertyTypeShapeError_typeUnknown | BlockInstallSharedPropertyTypeShapeError_typeUnsupported | BlockInstallSharedPropertyTypeShapeError_nestedTypeUnknown | BlockInstallSharedPropertyTypeShapeError_nestedArraysUnsupported | BlockInstallSharedPropertyTypeShapeError_plainTextTypeUnsupported | BlockInstallSharedPropertyTypeShapeError_structFieldTypeUnsupported;
interface BlockInstallStringParameterMaxLengthExceeded {
    length: number;
    maxLength: number;
}
interface BlockInstallTabularDatasourceShapeError_typeNotSupported {
    type: "typeNotSupported";
    typeNotSupported: TabularDatasourceTypeNotSupported;
}
interface BlockInstallTabularDatasourceShapeError_typeUnknown {
    type: "typeUnknown";
    typeUnknown: DatasourceLocatorTypeUnknown;
}
/**
 * Parent error type to group various errors related to tabular datasource shapes.
 */
type BlockInstallTabularDatasourceShapeError = BlockInstallTabularDatasourceShapeError_typeNotSupported | BlockInstallTabularDatasourceShapeError_typeUnknown;
interface BlockInternal_blockV1 {
    type: "blockV1";
    blockV1: BlockV1;
}
type BlockInternal = BlockInternal_blockV1;
/**
 * Internal identifiers with no meaning outside of the block they're found in.
 */
type BlockInternalId = string;
interface BlockManifestV1 {
    block: InstallableTransportBlock;
}
interface BlockRecommendation {
    body: RecommendationEntryBody;
    id: BlockRecommendationId;
}
type BlockRecommendationId = BlockInternalId;
interface BlockReference_existingBlock {
    type: "existingBlock";
    existingBlock: BlockInstallationRid;
}
interface BlockReference_newBlock {
    type: "newBlock";
    newBlock: InstallNewBlockInstructionId;
}
type BlockReference = BlockReference_existingBlock | BlockReference_newBlock;
interface BlockSet {
    about: LocalizedTitleAndDescription;
    additionalRecommendationVariants: Record<BlockSetRecommendationId, BlockSetRecommendationVariant>;
    blocks: Record<BlockSetBlockInstanceId, SingleVersionBlockReference>;
    createdByUser?: MultipassUserId | null | undefined;
    creationTimestamp: CreationTimestamp;
    defaultInstallationSettings?: DefaultInstallationSettings | null | undefined;
    id: BlockSetId;
    installationHints?: BlockSetInstallationHints | null | undefined;
    marketplaceMetadataVersion?: MarketplaceMetadataVersion | null | undefined;
    mavenCoordinateDependencies: Array<MavenCoordinateDependency>;
    mavenProductId?: MavenProductId | null | undefined;
    packagingLogicVersion?: PackagingLogicVersion | null | undefined;
    packagingSettings?: PackagingSettings | null | undefined;
    publishedByUser?: MultipassUserId | null | undefined;
    tags: Array<BlockSetTag>;
    tagsV2: BlockSetCategorizedTags;
    typedTags: Array<TagRid>;
    version: BlockSetVersion;
    versionId: BlockSetVersionId;
}
type BlockSetBlockInstanceId = BlockSetInternalId;
type BlockSetCategorizedTags = Record<BlockSetTagCategory, BlockSetTags>;
interface BlockSetCompassInstallLocation {
    namespaceRid: NamespaceRid;
    projectRid: CompassFolderRid;
}
interface BlockSetCreationAbortError {
    errorMessage: string;
}
interface BlockSetCreationAbortReason_userRequested {
    type: "userRequested";
    userRequested: Void;
}
interface BlockSetCreationAbortReason_error {
    type: "error";
    error: BlockSetCreationAbortError;
}
type BlockSetCreationAbortReason = BlockSetCreationAbortReason_userRequested | BlockSetCreationAbortReason_error;
interface BlockSetDocumentation {
    attachments: Array<AttachmentMetadata>;
    freeForm: FreeFormDocumentation;
    freeFormSections?: FreeFormDocumentationSections | null | undefined;
    links?: Links | null | undefined;
    localizedFreeFormSections?: LocalizedFreeFormDocumentationSections | null | undefined;
    thumbnail?: AttachmentMetadata | null | undefined;
}
/**
 * Two or more blocks output the same resource. This is not allowed.
 */
interface BlockSetDuplicateOutputShapesError {
    shapeId: OutputBlockSetShapeId;
}
/**
 * Block set level version of `ExternalServiceError`.
 */
interface BlockSetExternalServiceError {
    affectedInputs: Array<InputBlockSetShapeId>;
    affectedOutputs: Array<OutputBlockSetShapeId>;
    blockType?: BlockType | null | undefined;
    error?: MarketplaceSerializableError | null | undefined;
    errorInstanceId?: string | null | undefined;
    message: string;
}
type BlockSetId = string;
interface BlockSetInputActionTypeParameterReference {
    blockShape: BlockSetInputBlockShapeReference;
    parameterShapeId: ActionParameterShapeId;
}
interface BlockSetInputBlockShapeReference {
    blockInstanceId: BlockSetBlockInstanceId;
    shapeId: BlockShapeId;
}
/**
 * A set of shapes that are optional as a group (the user needs to supply either none or all of them). Shapes
 * that are marked with `isOptional = true` become required when part of an enabled group.
 *
 * For more information on input groups, see the documentation on the `InputGroup` object.
 */
interface BlockSetInputGroup {
    dependents: Array<OutputBlockSetShapeId>;
    displayMetadata: InputGroupDisplayMetadata;
    inputReferences: Array<InputBlockSetShapeId>;
}
type BlockSetInputGroupId = InputGroupId;
type BlockSetInputGroups = Record<BlockSetInputGroupId, InputGroupBlockSetMappingInfo>;
/**
 * The block set contains blocks that have a cyclical preallocate access dependency on each other. Marketplace
 * won't be able to install this block set in its current state as there is no valid ordering that ensures all
 * required outputs are preallocated before the blocks that depend on them.
 */
interface BlockSetInputsAccessedInPreallocateCycle {
    shortestCycle: Array<OutputBlockSetShapeId>;
}
/**
 * The block set contains blocks that have a cyclical dependency on each other due to the inputs they specify
 * as accessed in reconcile. Marketplace won't be able to install this block set in its current state as there
 * is no valid ordering that ensures all those inputs are materialized before the blocks are reconciled.
 */
interface BlockSetInputsAccessedInReconcileCycleV2 {
    shortestCycle: Array<OutputBlockSetShapeId>;
}
/**
 * Corresponds 1:1 with InputShape, but any usages of BlockInternalId are guaranteed to be replaced with
 * BlockSetInternalId
 */
type BlockSetInputShape = InputShape;
interface BlockSetInputShapeAdded {
}
interface BlockSetInputShapeDiff {
    diffSeverity: BlockSetInputShapeDiffSeverity;
    diffType: BlockSetInputShapeDiffType;
    inputBlockSetShapeId: InputBlockSetShapeId;
}
type BlockSetInputShapeDiffSeverity = "REQUIRES_ADDITIONAL_CONFIGURATION" | "BACKWARDS_COMPATIBLE";
interface BlockSetInputShapeDiffType_inputShapeAdded {
    type: "inputShapeAdded";
    inputShapeAdded: BlockSetInputShapeAdded;
}
interface BlockSetInputShapeDiffType_inputShapeRemoved {
    type: "inputShapeRemoved";
    inputShapeRemoved: BlockSetInputShapeRemoved;
}
interface BlockSetInputShapeDiffType_inputShapeModified {
    type: "inputShapeModified";
    inputShapeModified: BlockSetInputShapeModified;
}
type BlockSetInputShapeDiffType = BlockSetInputShapeDiffType_inputShapeAdded | BlockSetInputShapeDiffType_inputShapeRemoved | BlockSetInputShapeDiffType_inputShapeModified;
interface BlockSetInputShapeModified {
}
/**
 * DEPRECATED
 */
interface BlockSetInputShapeOld {
    isOptional: boolean;
    shape: InputShape;
}
interface BlockSetInputShapeReference {
    blockInstanceId: BlockSetBlockInstanceId;
    input: BlockShapeId;
}
/**
 * The block set input shape has an internal reference to (depends on) an output shape in the blockset.
 * This is illegal, since it creates a cyclic dependency upon installation of the blockset.
 */
interface BlockSetInputShapeReferencingOutputShapeV2 {
    inputShapeId: InputBlockSetShapeId;
    referencedOutputShapeId: OutputBlockSetShapeId;
}
interface BlockSetInputShapeRemoved {
}
type BlockSetInputShapes = Record<InputBlockSetShapeId, InputBlockSetMappingInfo>;
/**
 * The number of input shapes that need to be provided at installation time for the block set.
 */
interface BlockSetInputShapeSizeLimitCount {
    blockSetInputShapeLimit: number;
    numberOfBlockSetInputShapes: number;
    thresholdPercent: number;
}
/**
 * The backing shapes for a block set input could not be merged. Look up the backing shapes to figure out why.
 */
interface BlockSetInputShapesNotMergeableError {
    error?: MarketplaceSerializableError | null | undefined;
    shapeId: InputBlockSetShapeId;
}
interface BlockSetInputShapeWithBackingShapes {
    backingShapes: Array<ShapeReference>;
    resolvedShape?: ResolvedBlockSetInputShape | null | undefined;
    shape: BlockSetInputShape;
}
/**
 * A resolved block set input shape was created by merging multiple input shapes of different versions.
 */
interface BlockSetInputVersionSkew {
    inputShapeId: InputBlockSetShapeId;
    inputVersions: Array<InputShapeVersionAndBlockSetOutputs>;
}
interface BlockSetInstallationAccessDisallowedRationale_localMarketplaceNotFound {
    type: "localMarketplaceNotFound";
    localMarketplaceNotFound: LocalMarketplaceNotFoundRationale;
}
interface BlockSetInstallationAccessDisallowedRationale_installFromMarketplacePermissionDenied {
    type: "installFromMarketplacePermissionDenied";
    installFromMarketplacePermissionDenied: InstallFromMarketplacePermissionDeniedRationale;
}
interface BlockSetInstallationAccessDisallowedRationale_blockSetNotFound {
    type: "blockSetNotFound";
    blockSetNotFound: BlockSetNotFoundRationale;
}
interface BlockSetInstallationAccessDisallowedRationale_blockSetVersionNotFound {
    type: "blockSetVersionNotFound";
    blockSetVersionNotFound: BlockSetVersionNotFoundRationale;
}
interface BlockSetInstallationAccessDisallowedRationale_installBlockSetPermissionDenied {
    type: "installBlockSetPermissionDenied";
    installBlockSetPermissionDenied: InstallBlockSetPermissionDeniedRationale;
}
interface BlockSetInstallationAccessDisallowedRationale_editBlockSetInstallationsPermissionDenied {
    type: "editBlockSetInstallationsPermissionDenied";
    editBlockSetInstallationsPermissionDenied: EditBlockSetInstallationsPermissionDeniedRationale;
}
interface BlockSetInstallationAccessDisallowedRationale_installInOntologyPermissionDenied {
    type: "installInOntologyPermissionDenied";
    installInOntologyPermissionDenied: InstallInOntologyPermissionDeniedRationale;
}
interface BlockSetInstallationAccessDisallowedRationale_notAuthorizedToDeclassify {
    type: "notAuthorizedToDeclassify";
    notAuthorizedToDeclassify: NotAuthorizedToDeclassifyRationale;
}
interface BlockSetInstallationAccessDisallowedRationale_notAuthorizedToUseMarkings {
    type: "notAuthorizedToUseMarkings";
    notAuthorizedToUseMarkings: NotAuthorizedToUseMarkingsRationale;
}
interface BlockSetInstallationAccessDisallowedRationale_partiallyDeletedInstallation {
    type: "partiallyDeletedInstallation";
    partiallyDeletedInstallation: PartiallyDeletedInstallationRationale;
}
/**
 * These must map to errors that will be thrown by the install endpoint
 */
type BlockSetInstallationAccessDisallowedRationale = BlockSetInstallationAccessDisallowedRationale_localMarketplaceNotFound | BlockSetInstallationAccessDisallowedRationale_installFromMarketplacePermissionDenied | BlockSetInstallationAccessDisallowedRationale_blockSetNotFound | BlockSetInstallationAccessDisallowedRationale_blockSetVersionNotFound | BlockSetInstallationAccessDisallowedRationale_installBlockSetPermissionDenied | BlockSetInstallationAccessDisallowedRationale_editBlockSetInstallationsPermissionDenied | BlockSetInstallationAccessDisallowedRationale_installInOntologyPermissionDenied | BlockSetInstallationAccessDisallowedRationale_notAuthorizedToDeclassify | BlockSetInstallationAccessDisallowedRationale_notAuthorizedToUseMarkings | BlockSetInstallationAccessDisallowedRationale_partiallyDeletedInstallation;
interface BlockSetInstallationCapabilities {
    canDeleteInstallation: DeleteBlockSetInstallationAllowance;
    canEditInstallation: EditBlockSetInstallationAllowance;
    canEditInstallationSettings: EditBlockSetInstallationSettingsAllowance;
}
interface BlockSetInstallationDisplayMetadata {
    description: string;
    displayName: string;
}
interface BlockSetInstallationDoesNotExist {
    blockSetInstallationRid: BlockSetInstallationRid;
}
interface BlockSetInstallationHint {
    equivalentBlockSetInputShapeReference: EquivalentInputReferences;
}
type BlockSetInstallationHintId = BlockSetInternalId;
interface BlockSetInstallationHints_v1 {
    type: "v1";
    v1: BlockSetInstallationHintsV1;
}
/**
 * Captures equivalencies between inputs. This was originally built as something that can also incorporate
 * internal recommendations in the future, but is being deprecated in favor of BlockSetToBlockMapping, which
 * contains this, plus a few other concepts.
 * An installation hint exists for every input shape on the block set installation.
 */
type BlockSetInstallationHints = BlockSetInstallationHints_v1;
type BlockSetInstallationHintsV1 = Record<BlockSetInstallationHintId, BlockSetInstallationHint>;
type BlockSetInstallationImmutability = "MUTABLE" | "IMMUTABLE";
interface BlockSetInstallationJob {
    associatedInstallations: Array<BlockSetInstallationJobAssociatedInstallation>;
    blockSetErrors: Array<BlockSetInstallationJobError>;
    jobErrors: Array<MarketplaceSerializableError>;
    metadata: BlockSetInstallationJobMetadata;
}
interface BlockSetInstallationJobAssociatedInstallation {
    cleanupUnusedShapesStatuses: CleanupUnusedShapesStatuses;
    marketplaceRid: MarketplaceRid;
    rid: BlockSetInstallationRid;
    shapeStatuses: ShapeInstallationStatuses;
    targetVersionId: BlockSetVersionId;
}
interface BlockSetInstallationJobCapabilities {
    canCancelInstallationJob: CancelInstallationJobAllowance;
}
interface BlockSetInstallationJobError {
    blockError: BlockInstallError;
}
interface BlockSetInstallationJobMetadata {
    blockSetInstallations: Array<BlockSetInstallationRid>;
    blockSetInstallationsV2: Array<AssociatedBlockSetInstallationIdentifiers>;
    installationCreator: MultipassUserId;
    isRetryable: boolean;
    jobRid: BlockSetInstallationJobRid;
    lastActivityAt: string;
    secondsElapsed: number;
    status: BlockSetInstallationJobStatus;
    submittedAt: string;
}
type BlockSetInstallationJobRid = string;
interface BlockSetInstallationJobStatus_inProgress {
    type: "inProgress";
    inProgress: BlockSetInstallationJobStatusInProgress;
}
interface BlockSetInstallationJobStatus_building {
    type: "building";
    building: BlockSetInstallationJobStatusBuilding;
}
interface BlockSetInstallationJobStatus_success {
    type: "success";
    success: BlockSetInstallationJobStatusSuccess;
}
interface BlockSetInstallationJobStatus_error {
    type: "error";
    error: BlockSetInstallationJobStatusError;
}
type BlockSetInstallationJobStatus = BlockSetInstallationJobStatus_inProgress | BlockSetInstallationJobStatus_building | BlockSetInstallationJobStatus_success | BlockSetInstallationJobStatus_error;
/**
 * The status of a job whilst backing datasources and objects are being built and indexed.
 */
interface BlockSetInstallationJobStatusBuilding {
    isPendingCancellation: boolean;
    percentageCompleted: number;
}
interface BlockSetInstallationJobStatusError {
    errors: Array<BlockSetInstallationJobError>;
    granularErrorStatus?: GranularErrorStatus | null | undefined;
    wasCancelled: boolean;
}
/**
 * The status of a job in the process of reconciling blocks, creating and updating resources. This is distinct
 * from the actual data content of resources which is tracked in the BlockSetInstallationJobStatusBuilding status
 */
interface BlockSetInstallationJobStatusInProgress {
    isPendingCancellation: boolean;
    percentageCompleted: number;
}
interface BlockSetInstallationJobStatusSuccess {
}
interface BlockSetInstallationMetadata {
    appliedRecommendations: Array<AppliedExternalRecommendationV2>;
    blockSetId: BlockSetId;
    blockSetInstallationRid: BlockSetInstallationRid;
    blockSetVersions: Array<BlockSetVersionId>;
    createdByJobRid?: BlockSetInstallationJobRid | null | undefined;
    displayMetadata: BlockSetInstallationDisplayMetadata;
    installationCreator: MultipassUserId;
    installationTimestamp: string;
    installLocation: BlockSetInstallLocation;
    isInTrash: boolean;
    latestFinishedJobRid?: BlockSetInstallationJobRid | null | undefined;
    latestJobRid?: BlockSetInstallationJobRid | null | undefined;
    marketplaceRid: MarketplaceRid;
    targetVersion: BlockSetVersionId;
    targetVersionV2?: BlockSetVersionId | null | undefined;
    updatedAtTimestamp: string;
    updatedLastBy: MultipassUserId;
}
/**
 * Refers to a block set output shape of a specific block set installation.
 */
interface BlockSetInstallationOutputReference {
    blockSetInstallationRid: BlockSetInstallationRid;
    outputShapeId: OutputBlockSetShapeId;
}
interface BlockSetInstallationResolvedEntities {
    resolvedInputGroups: Record<BlockSetInputGroupId, ResolvedBlockSetInputGroup>;
    resolvedInputs: Record<InputBlockSetShapeId, ResolvedBlockSetInputShape>;
    resolvedInputsV2: Record<InputBlockSetShapeId, BlockSetInstallationResolvedInput>;
    resolvedOutputs: Record<OutputBlockSetShapeId, ResolvedBlockSetOutputShape>;
}
interface BlockSetInstallationResolvedInput {
    fromSource: BlockSetInstallationResolvedInputSource;
    resolvedInput: ResolvedBlockSetInputShape;
}
interface BlockSetInstallationResolvedInputSource_externallyRecommendedOutput {
    type: "externallyRecommendedOutput";
    externallyRecommendedOutput: ExternallyRecommendedOutput;
}
interface BlockSetInstallationResolvedInputSource_manuallyProvided {
    type: "manuallyProvided";
    manuallyProvided: ManuallyProvidedInput;
}
interface BlockSetInstallationResolvedInputSource_fromDefault {
    type: "fromDefault";
    fromDefault: FromDefaultInput;
}
type BlockSetInstallationResolvedInputSource = BlockSetInstallationResolvedInputSource_externallyRecommendedOutput | BlockSetInstallationResolvedInputSource_manuallyProvided | BlockSetInstallationResolvedInputSource_fromDefault;
interface BlockSetInstallationResolvedInputSourceV2_externallyRecommendedOutput {
    type: "externallyRecommendedOutput";
    externallyRecommendedOutput: ExternallyRecommendedOutputV2;
}
interface BlockSetInstallationResolvedInputSourceV2_manuallyProvided {
    type: "manuallyProvided";
    manuallyProvided: ManuallyProvidedInputV2;
}
interface BlockSetInstallationResolvedInputSourceV2_fromDefault {
    type: "fromDefault";
    fromDefault: FromDefaultInput;
}
type BlockSetInstallationResolvedInputSourceV2 = BlockSetInstallationResolvedInputSourceV2_externallyRecommendedOutput | BlockSetInstallationResolvedInputSourceV2_manuallyProvided | BlockSetInstallationResolvedInputSourceV2_fromDefault;
interface BlockSetInstallationResolvedInputSourceV3_externallyRecommendedOutput {
    type: "externallyRecommendedOutput";
    externallyRecommendedOutput: ExternallyRecommendedOutputV2;
}
interface BlockSetInstallationResolvedInputSourceV3_manuallyProvided {
    type: "manuallyProvided";
    manuallyProvided: ManuallyProvidedInputV2;
}
interface BlockSetInstallationResolvedInputSourceV3_fromDefault {
    type: "fromDefault";
    fromDefault: FromDefaultInput;
}
interface BlockSetInstallationResolvedInputSourceV3_automapped {
    type: "automapped";
    automapped: AutomappedInput;
}
type BlockSetInstallationResolvedInputSourceV3 = BlockSetInstallationResolvedInputSourceV3_externallyRecommendedOutput | BlockSetInstallationResolvedInputSourceV3_manuallyProvided | BlockSetInstallationResolvedInputSourceV3_fromDefault | BlockSetInstallationResolvedInputSourceV3_automapped;
interface BlockSetInstallationResolvedInputV2 {
    source: BlockSetInstallationResolvedInputSourceV2;
}
interface BlockSetInstallationResolvedInputV3 {
    source: BlockSetInstallationResolvedInputSourceV3;
}
interface BlockSetInstallationResolvedShapes {
    resolvedInputGroups: Record<BlockSetInputGroupId, ResolvedBlockSetInputGroup>;
    resolvedInputs: Record<InputBlockSetShapeId, BlockSetInstallationResolvedInputV2>;
    resolvedOutputs: Record<OutputBlockSetShapeId, ResolvedBlockSetOutputShape>;
}
/**
 * Identifies a block set installation.
 */
type BlockSetInstallationRid = string;
interface BlockSetInstallationTargetState {
    displayMetadata: BlockSetInstallationDisplayMetadata;
    recommendationsToApply: Array<ToBeAppliedExternalRecommendationV2>;
    resolvedInputGroups: Record<BlockSetInputGroupId, ResolvedBlockSetInputGroup>;
    resolvedInputShapes: Record<InputBlockSetShapeId, ResolvedBlockSetInputShape>;
    resolvedInputShapesV2: Record<InputBlockSetShapeId, InstallationResolvedInputShape>;
    resolvedOutputShapesToAttach: Record<OutputBlockSetShapeId, ResolvedBlockSetOutputShape>;
    targetVersion: InstallableBlockSetVersionId;
}
/**
 * A block set installation records that a block set has been installed in a given installation context.
 */
interface BlockSetInstallationV2 {
    appliedRecommendations: Array<AppliedExternalRecommendationV2>;
    blockInstanceInstallationRids: Record<BlockSetBlockInstanceId, BlockInstallationRid>;
    blockSetId: BlockSetId;
    blockSetInstallationRid: BlockSetInstallationRid;
    blockSetVersionId: BlockSetVersionId;
    blockSetVersionIdV2?: BlockSetVersionId | null | undefined;
    blockSetVersions: Array<BlockSetVersionId>;
    createdByJobRid?: InstallBlocksJobRid | null | undefined;
    displayMetadata: BlockSetInstallationDisplayMetadata;
    installationContextId: InstallationContextId;
    installationCreator: MultipassUserId;
    installationTimestamp: InstallationTimestamp;
    installLocation: BlockSetInstallLocation;
    isInTrash: boolean;
    lastConsistentState?: ConsistentBlockSetInstallationState | null | undefined;
    latestFinishedJobRid?: InstallBlocksJobRid | null | undefined;
    latestInstallJob?: InstallBlocksJobId | null | undefined;
    latestInstallJobRid?: InstallBlocksJobRid | null | undefined;
    marketplaceRid: MarketplaceRid;
    updatedAtTimestamp: UpdatedAtTimestamp;
    updatedLastBy: MultipassUserId;
}
/**
 * The location that a block set has been installed into. Available as a field on `BlockSetInstallationV2`.
 * This is different from `TargetInstallLocation`, which is used by the `BlockInstallationServiceV2.installBlocks`
 * and represents the target location that a set of blocks are going to be installed into.
 */
interface BlockSetInstallLocation {
    compass: BlockSetCompassInstallLocation;
    ontology?: OntologyInstallLocation | null | undefined;
}
interface BlockSetInstallValidationError {
    blockSetReference: BlockSetReference;
    error: BlockSetInstallValidationErrorDetail;
}
interface BlockSetInstallValidationErrorDetail_blockSetInstallationDoesNotExist {
    type: "blockSetInstallationDoesNotExist";
    blockSetInstallationDoesNotExist: BlockSetInstallationDoesNotExist;
}
interface BlockSetInstallValidationErrorDetail_blockSetVersionRecalled {
    type: "blockSetVersionRecalled";
    blockSetVersionRecalled: BlockSetVersionRecalled;
}
interface BlockSetInstallValidationErrorDetail_duplicateBlockReference {
    type: "duplicateBlockReference";
    duplicateBlockReference: DuplicateBlockReference;
}
interface BlockSetInstallValidationErrorDetail_invalidBlockReference {
    type: "invalidBlockReference";
    invalidBlockReference: InvalidBlockReference;
}
interface BlockSetInstallValidationErrorDetail_invalidInstallationProject {
    type: "invalidInstallationProject";
    invalidInstallationProject: InvalidInstallationProject;
}
interface BlockSetInstallValidationErrorDetail_invalidDefaultInstallationBuildOptionsNotOverridden {
    type: "invalidDefaultInstallationBuildOptionsNotOverridden";
    invalidDefaultInstallationBuildOptionsNotOverridden: Void;
}
interface BlockSetInstallValidationErrorDetail_missingCbacMarkingConstraint {
    type: "missingCbacMarkingConstraint";
    missingCbacMarkingConstraint: MissingCbacMarkingConstraint;
}
interface BlockSetInstallValidationErrorDetail_multipleBlockSetInstallsWithSameKey {
    type: "multipleBlockSetInstallsWithSameKey";
    multipleBlockSetInstallsWithSameKey: Void;
}
interface BlockSetInstallValidationErrorDetail_ontologyPackageInDefaultOntologyNotAllowed {
    type: "ontologyPackageInDefaultOntologyNotAllowed";
    ontologyPackageInDefaultOntologyNotAllowed: OntologyPackageInDefaultOntologyNotAllowed;
}
interface BlockSetInstallValidationErrorDetail_targetInstallLocationDoesNotMatchCurrentLocation {
    type: "targetInstallLocationDoesNotMatchCurrentLocation";
    targetInstallLocationDoesNotMatchCurrentLocation: TargetInstallLocationDoesNotMatchCurrentLocation;
}
interface BlockSetInstallValidationErrorDetail_targetOntologyIsNotLinkedToTargetNamespace {
    type: "targetOntologyIsNotLinkedToTargetNamespace";
    targetOntologyIsNotLinkedToTargetNamespace: TargetOntologyIsNotLinkedToTargetNamespace;
}
interface BlockSetInstallValidationErrorDetail_newInstallationOfASingletonBlockSetThatIsAlreadyInstalled {
    type: "newInstallationOfASingletonBlockSetThatIsAlreadyInstalled";
    newInstallationOfASingletonBlockSetThatIsAlreadyInstalled: NewInstallationOfSingletonBlockSetThatIsAlreadyInstalled;
}
interface BlockSetInstallValidationErrorDetail_upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes {
    type: "upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes";
    upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes: UpgradeOfSingletonBlockSetThatIsInstalledMultipleTimes;
}
interface BlockSetInstallValidationErrorDetail_unknownError {
    type: "unknownError";
    unknownError: Void;
}
interface BlockSetInstallValidationErrorDetail_serializable {
    type: "serializable";
    serializable: MarketplaceSerializableError;
}
type BlockSetInstallValidationErrorDetail = BlockSetInstallValidationErrorDetail_blockSetInstallationDoesNotExist | BlockSetInstallValidationErrorDetail_blockSetVersionRecalled | BlockSetInstallValidationErrorDetail_duplicateBlockReference | BlockSetInstallValidationErrorDetail_invalidBlockReference | BlockSetInstallValidationErrorDetail_invalidInstallationProject | BlockSetInstallValidationErrorDetail_invalidDefaultInstallationBuildOptionsNotOverridden | BlockSetInstallValidationErrorDetail_missingCbacMarkingConstraint | BlockSetInstallValidationErrorDetail_multipleBlockSetInstallsWithSameKey | BlockSetInstallValidationErrorDetail_ontologyPackageInDefaultOntologyNotAllowed | BlockSetInstallValidationErrorDetail_targetInstallLocationDoesNotMatchCurrentLocation | BlockSetInstallValidationErrorDetail_targetOntologyIsNotLinkedToTargetNamespace | BlockSetInstallValidationErrorDetail_newInstallationOfASingletonBlockSetThatIsAlreadyInstalled | BlockSetInstallValidationErrorDetail_upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes | BlockSetInstallValidationErrorDetail_unknownError | BlockSetInstallValidationErrorDetail_serializable;
interface BlockSetInstallValidationErrorDetailV2_blockSetInstallationDoesNotExist {
    type: "blockSetInstallationDoesNotExist";
    blockSetInstallationDoesNotExist: BlockSetInstallationDoesNotExist;
}
interface BlockSetInstallValidationErrorDetailV2_blockSetVersionRecalled {
    type: "blockSetVersionRecalled";
    blockSetVersionRecalled: BlockSetVersionRecalled;
}
interface BlockSetInstallValidationErrorDetailV2_externalServiceError {
    type: "externalServiceError";
    externalServiceError: BlockSetExternalServiceError;
}
interface BlockSetInstallValidationErrorDetailV2_incompatibleLinkedProduct {
    type: "incompatibleLinkedProduct";
    incompatibleLinkedProduct: IncompatibleLinkedProduct;
}
interface BlockSetInstallValidationErrorDetailV2_installingBlockSetsFromMultipleStores {
    type: "installingBlockSetsFromMultipleStores";
    installingBlockSetsFromMultipleStores: Void;
}
interface BlockSetInstallValidationErrorDetailV2_integrationValidationError {
    type: "integrationValidationError";
    integrationValidationError: BlockSetIntegrationValidationError;
}
interface BlockSetInstallValidationErrorDetailV2_invalidDefaultInstallationBuildOptionsNotOverridden {
    type: "invalidDefaultInstallationBuildOptionsNotOverridden";
    invalidDefaultInstallationBuildOptionsNotOverridden: Void;
}
interface BlockSetInstallValidationErrorDetailV2_invalidLinkedProduct {
    type: "invalidLinkedProduct";
    invalidLinkedProduct: InvalidLinkedProduct;
}
interface BlockSetInstallValidationErrorDetailV2_missingCbacMarkingConstraint {
    type: "missingCbacMarkingConstraint";
    missingCbacMarkingConstraint: MissingCbacMarkingConstraint;
}
interface BlockSetInstallValidationErrorDetailV2_multipleBlockSetsInstalledIntoSameProject {
    type: "multipleBlockSetsInstalledIntoSameProject";
    multipleBlockSetsInstalledIntoSameProject: Void;
}
interface BlockSetInstallValidationErrorDetailV2_notAllInstallationsInSameOntology {
    type: "notAllInstallationsInSameOntology";
    notAllInstallationsInSameOntology: Void;
}
interface BlockSetInstallValidationErrorDetailV2_ontologyInstallLocationNotDefined {
    type: "ontologyInstallLocationNotDefined";
    ontologyInstallLocationNotDefined: OntologyInstallLocationNotDefined;
}
interface BlockSetInstallValidationErrorDetailV2_ontologyPackageInDefaultOntologyNotAllowed {
    type: "ontologyPackageInDefaultOntologyNotAllowed";
    ontologyPackageInDefaultOntologyNotAllowed: OntologyPackageInDefaultOntologyNotAllowed;
}
interface BlockSetInstallValidationErrorDetailV2_resourceUsedAsBothInputAndOutput {
    type: "resourceUsedAsBothInputAndOutput";
    resourceUsedAsBothInputAndOutput: ResourceUsedAsBothInputAndOutput;
}
interface BlockSetInstallValidationErrorDetailV2_targetOntologyIsNotLinkedToTargetNamespace {
    type: "targetOntologyIsNotLinkedToTargetNamespace";
    targetOntologyIsNotLinkedToTargetNamespace: TargetOntologyIsNotLinkedToTargetNamespace;
}
interface BlockSetInstallValidationErrorDetailV2_newInstallationOfASingletonBlockSetThatIsAlreadyInstalled {
    type: "newInstallationOfASingletonBlockSetThatIsAlreadyInstalled";
    newInstallationOfASingletonBlockSetThatIsAlreadyInstalled: NewInstallationOfSingletonBlockSetThatIsAlreadyInstalled;
}
interface BlockSetInstallValidationErrorDetailV2_upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes {
    type: "upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes";
    upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes: UpgradeOfSingletonBlockSetThatIsInstalledMultipleTimes;
}
interface BlockSetInstallValidationErrorDetailV2_unknownError {
    type: "unknownError";
    unknownError: Void;
}
interface BlockSetInstallValidationErrorDetailV2_serializable {
    type: "serializable";
    serializable: MarketplaceSerializableError;
}
type BlockSetInstallValidationErrorDetailV2 = BlockSetInstallValidationErrorDetailV2_blockSetInstallationDoesNotExist | BlockSetInstallValidationErrorDetailV2_blockSetVersionRecalled | BlockSetInstallValidationErrorDetailV2_externalServiceError | BlockSetInstallValidationErrorDetailV2_incompatibleLinkedProduct | BlockSetInstallValidationErrorDetailV2_installingBlockSetsFromMultipleStores | BlockSetInstallValidationErrorDetailV2_integrationValidationError | BlockSetInstallValidationErrorDetailV2_invalidDefaultInstallationBuildOptionsNotOverridden | BlockSetInstallValidationErrorDetailV2_invalidLinkedProduct | BlockSetInstallValidationErrorDetailV2_missingCbacMarkingConstraint | BlockSetInstallValidationErrorDetailV2_multipleBlockSetsInstalledIntoSameProject | BlockSetInstallValidationErrorDetailV2_notAllInstallationsInSameOntology | BlockSetInstallValidationErrorDetailV2_ontologyInstallLocationNotDefined | BlockSetInstallValidationErrorDetailV2_ontologyPackageInDefaultOntologyNotAllowed | BlockSetInstallValidationErrorDetailV2_resourceUsedAsBothInputAndOutput | BlockSetInstallValidationErrorDetailV2_targetOntologyIsNotLinkedToTargetNamespace | BlockSetInstallValidationErrorDetailV2_newInstallationOfASingletonBlockSetThatIsAlreadyInstalled | BlockSetInstallValidationErrorDetailV2_upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes | BlockSetInstallValidationErrorDetailV2_unknownError | BlockSetInstallValidationErrorDetailV2_serializable;
interface BlockSetInstallValidationErrorV2 {
    blockSetReference: BlockSetReference;
    error: BlockSetInstallValidationErrorDetailV2;
    severity: ErrorSeverity;
}
interface BlockSetIntegrationValidationError {
    error: TypedBlockInstallServiceValidationError;
}
/**
 * Internal identifiers with no meaning outside of the block set they're found in
 */
type BlockSetInternalId = string;
interface BlockSetInternalRecommendation {
    fulfilledBy: OutputBlockSetShapeId;
    inputs: Array<ShapeReference>;
}
/**
 * An internal recommendation between an output and an input was created by merging multiple resolved shapes of
 * different versions.
 */
interface BlockSetInternalRecommendationVersionSkew {
    inputVersions: Array<InputShapeVersionAndBlockSetOutputs>;
    output: OutputBlockSetShapeId;
    outputVersion?: ResourceVersion | null | undefined;
}
interface BlockSetManifestV1 {
    blockSet: InstallableTransportBlockSet;
}
interface BlockSetNamedVersion {
    versionId: BlockSetVersionId;
    versionName: BlockSetVersion;
}
interface BlockSetNotFoundRationale {
    blockSetId: BlockSetId;
    marketplaceRid: MarketplaceRid;
}
interface BlockSetOutputReference {
    blockSetReference: BlockSetReference;
    outputShapeId: OutputBlockSetShapeId;
}
/**
 * Corresponds 1:1 with OutputShape, but any usages of BlockInternalId are guaranteed to be replaced with
 * BlockSetInternalId
 */
type BlockSetOutputShape = OutputShape;
interface BlockSetOutputShapeAdded {
}
interface BlockSetOutputShapeDiff {
    diffSeverity: BlockSetOutputShapeDiffSeverity;
    diffType: BlockSetOutputShapeDiffType;
    outputBlockSetShapeId: OutputBlockSetShapeId;
}
type BlockSetOutputShapeDiffSeverity = "BACKWARDS_INCOMPATIBLE" | "BACKWARDS_COMPATIBLE";
interface BlockSetOutputShapeDiffType_outputShapeAdded {
    type: "outputShapeAdded";
    outputShapeAdded: BlockSetOutputShapeAdded;
}
interface BlockSetOutputShapeDiffType_outputShapeRemoved {
    type: "outputShapeRemoved";
    outputShapeRemoved: BlockSetOutputShapeRemoved;
}
interface BlockSetOutputShapeDiffType_outputShapeModified {
    type: "outputShapeModified";
    outputShapeModified: BlockSetOutputShapeModified;
}
type BlockSetOutputShapeDiffType = BlockSetOutputShapeDiffType_outputShapeAdded | BlockSetOutputShapeDiffType_outputShapeRemoved | BlockSetOutputShapeDiffType_outputShapeModified;
interface BlockSetOutputShapeMetadata {
    createdAt: string;
    createdForBlockSetVersion: BlockSetVersionId;
}
interface BlockSetOutputShapeModified {
}
/**
 * DEPRECATED
 */
interface BlockSetOutputShapeOld {
    dependencies: Array<BlockSetShapeDependency>;
    producedByBlockType: BlockType;
    shape: OutputShape;
}
interface BlockSetOutputShapeReference {
    blockInstanceId: BlockSetBlockInstanceId;
    output: BlockShapeId;
}
interface BlockSetOutputShapeRemoved {
}
type BlockSetOutputShapes = Record<OutputBlockSetShapeId, OutputBlockSetMappingInfo>;
interface BlockSetOutputShapeSizeLimitCount {
    numberOfOutputShapes: number;
    outputShapeLimit: number;
    thresholdPercent: number;
}
interface BlockSetOutputShapeWithBackingShape {
    backingShape: ShapeReference;
    producedByBlockType: BlockType;
    resolvedShape: ResolvedBlockSetOutputShape;
    shape: BlockSetOutputShape;
}
/**
 * A member sourced from a marketplace store.
 */
interface BlockSetProductGroupMember {
    blockSetId: BlockSetId;
    marketplaceRid: MarketplaceRid;
    versionPolicy: BlockSetProductGroupMemberVersionPolicy;
}
interface BlockSetProductGroupMemberVersionPolicy_latest {
    type: "latest";
    latest: LatestVersionPolicy;
}
interface BlockSetProductGroupMemberVersionPolicy_pinnedVersion {
    type: "pinnedVersion";
    pinnedVersion: PinnedVersionPolicy;
}
interface BlockSetProductGroupMemberVersionPolicy_releaseChannel {
    type: "releaseChannel";
    releaseChannel: ReleaseChannelVersionPolicy;
}
/**
 * Determines which version of a block set is resolved for a product group member.
 */
type BlockSetProductGroupMemberVersionPolicy = BlockSetProductGroupMemberVersionPolicy_latest | BlockSetProductGroupMemberVersionPolicy_pinnedVersion | BlockSetProductGroupMemberVersionPolicy_releaseChannel;
interface BlockSetPublishingJobFailure {
    error?: any | null | undefined;
}
interface BlockSetPublishingJobInProgress {
}
/**
 * Rid of a block set publishing job.
 */
type BlockSetPublishingJobRid = string;
interface BlockSetPublishingJobSuccess {
    artifactUri: ApolloArtifactUri;
}
interface BlockSetRecommendationBody_simple {
    type: "simple";
    simple: SimpleBlockSetRecommendation;
}
interface BlockSetRecommendationBody_actionType {
    type: "actionType";
    actionType: ActionTypeBlockSetRecommendation;
}
/**
 * DEPRECATED: Replaced by block set shapes internal recommendations.
 */
type BlockSetRecommendationBody = BlockSetRecommendationBody_simple | BlockSetRecommendationBody_actionType;
type BlockSetRecommendationId = BlockSetInternalId;
/**
 * DEPRECATED: Replaced by block set shapes internal recommendations.
 */
interface BlockSetRecommendationVariant {
    entries: Array<BlockSetRecommendationBody>;
    id: BlockSetRecommendationId;
}
interface BlockSetReference_existingBlockSet {
    type: "existingBlockSet";
    existingBlockSet: BlockSetInstallationRid;
}
interface BlockSetReference_newBlockSet {
    type: "newBlockSet";
    newBlockSet: NewBlockSetInstallationId;
}
type BlockSetReference = BlockSetReference_existingBlockSet | BlockSetReference_newBlockSet;
/**
 * Security RID for a block set. The locator part of the RID will _not_ match the `BlockSetId` UUID, as the same
 * block set can be imported to multiple stores on the same stack, which means that `BlockSetId` is not
 * necessarily unique within a stack.
 */
type BlockSetSecurityRid = string;
/**
 * The input and output shapes of the blocks in a block set are deduplicated to block set shapes, where resources
 * that are referenced by different shapes on one or more blocks are combined to form one block set shape.
 *
 * If the resource is produced by a block during installation, it is a block set *output* shape.
 *
 * For example, if a an Ontology block produces an object type which is consumed as input by a Workshop block,
 * there will be one block set shape for the object type, which is an output item. We say that this block set
 * shape is derived from both the Ontology block's output and the Workshop block's input.
 */
interface BlockSetShape {
    internal: BlockSetShapeInternal;
}
/**
 * Representation of blocks - we create one entry for each block.
 */
interface BlockSetShapeDependencies {
    dependencies: OutputShapeDependencies;
    metadata?: BlockSetOutputShapeMetadata | null | undefined;
    outputs: Array<OutputBlockSetShapeId>;
}
/**
 * The block set shape inputs of the block which output this shape.
 */
interface BlockSetShapeDependency {
    blockSetShapeId: BlockSetShapeId;
    isOptional: boolean;
}
interface BlockSetShapeDiffCounts {
    added: number;
    modified: number;
    removed: number;
}
/**
 * The ID for deduplicated shapes that exist on different blocks that are connected through install hints and
 * recommendations.
 */
type BlockSetShapeId = BlockInternalId;
interface BlockSetShapeInternal_input {
    type: "input";
    input: BlockSetInputShapeOld;
}
interface BlockSetShapeInternal_output {
    type: "output";
    output: BlockSetOutputShapeOld;
}
/**
 * DEPRECATED
 */
type BlockSetShapeInternal = BlockSetShapeInternal_input | BlockSetShapeInternal_output;
/**
 * Mapping information between shapes on all blocks and the corresponding deduplicated BlockSetShapes.
 */
type BlockSetShapeMappingInfo = Record<BlockSetBlockInstanceId, BlockShapesMappingInfo>;
/**
 * Contains output block set shape IDs and resolved output shapes associated with the error.
 * Some shape IDs are removed in bulk, and thus an error may be associated with multiple shape IDs.
 */
interface BlockSetShapesRemovalError {
    error: ShapesRemovalError;
    resolvedOutputs: Record<OutputBlockSetShapeId, ResolvedOutputShape>;
}
interface BlockSetShapeVisibility_visible {
    type: "visible";
    visible: Void;
}
interface BlockSetShapeVisibility_invisible {
    type: "invisible";
    invisible: Void;
}
/**
 * The visibility of the shape. Can be changed by the packager. If invisible, the shape will not be shown to
 * the installing user. The shape be optional, or have a preset that does not allow custom values
 * (see `presets.PRESET_ENFORCEMENT`).
 */
type BlockSetShapeVisibility = BlockSetShapeVisibility_visible | BlockSetShapeVisibility_invisible;
/**
 * The block set has reached or is approaching the maximum size constraints. We will start to warn users of this
 * when we reach 75% in any constraint, and we will block packaging if size exceeds 100%.
 * Constraints are measured for number of block set input shapes, block input shapes and output shapes.
 */
interface BlockSetSizeLimitThresholdReached {
    blockInputShapeLimitCount?: BlockInputShapeSizeLimitCount | null | undefined;
    blockSetInputLimitCount?: BlockSetInputShapeSizeLimitCount | null | undefined;
    blockSetOutputLimitCount?: BlockSetOutputShapeSizeLimitCount | null | undefined;
    blockSetTotalLimitCount?: BlockSetTotalShapeSizeLimitCount | null | undefined;
    thresholdPercent: number;
}
type BlockSetTag = string;
type BlockSetTagCategory = string;
type BlockSetTags = Array<BlockSetTag>;
interface BlockSetTotalShapeSizeLimitCount {
    blockSetTotalShapeLimit: number;
    numberOfInputShapes: number;
    numberOfOutputShapes: number;
    thresholdPercent: number;
}
interface BlockSetUpdatedEventKeyV2 {
    blockSetId: BlockSetId;
    marketplaceRid: MarketplaceRid;
}
type BlockSetVersion = string;
interface BlockSetVersionDiff {
    inputShapeDiffs: Array<BlockSetInputShapeDiff>;
    outputShapeDiffs: Array<BlockSetOutputShapeDiff>;
}
interface BlockSetVersionDiffFromEmptyRequest {
    blockSetVersionId: BlockSetVersionId;
    marketplaceRid: MarketplaceRid;
}
interface BlockSetVersionDiffRequest {
    afterBlockSetVersionId: BlockSetVersionId;
    afterMarketplaceRid: MarketplaceRid;
    beforeBlockSetVersionId: BlockSetVersionId;
    beforeMarketplaceRid: MarketplaceRid;
}
interface BlockSetVersionDiffSummary {
    inputShapes: BlockSetShapeDiffCounts;
    outputShapes: BlockSetShapeDiffCounts;
}
/**
 * At least one output spec is required.
 */
interface BlockSetVersionEmptyOutputSpecsError {
}
/**
 * The block set version's fallback title is blank.
 */
interface BlockSetVersionEmptyTitleError {
}
interface BlockSetVersionErrorRecovery_idle {
    type: "idle";
    idle: BlockSetVersionIdleError;
}
interface BlockSetVersionErrorRecovery_materializing {
    type: "materializing";
    materializing: BlockSetVersionMaterializingError;
}
interface BlockSetVersionErrorRecovery_finalizing {
    type: "finalizing";
    finalizing: BlockSetVersionFinalizingError;
}
/**
 * Error recovery in after materializing or finalizing errors.
 */
type BlockSetVersionErrorRecovery = BlockSetVersionErrorRecovery_idle | BlockSetVersionErrorRecovery_materializing | BlockSetVersionErrorRecovery_finalizing;
interface BlockSetVersionFinalizingError {
    error: MarketplaceSerializableError;
    errorMessage: string;
}
/**
 * Unique identifier for a particular version of a block set. That is, 1:1 with (BlockSetId, BlockSetVersion) tuples.
 */
type BlockSetVersionId = string;
interface BlockSetVersionIdleError {
    errorMessage: string;
}
/**
 * Matches ranges of versions. Use an `x` instead of a version number to represent wildcards. Once one level
 * has a wildcard, all subsequent ones must be as well (i.e. `1.x.4` is not supported, while `1.x.x` is). Any
 * missing levels are assumed to be wildcards (i.e. `1.x` is equivalent to `1.x.x`).
 */
type BlockSetVersionMatcher = string;
interface BlockSetVersionMaterializingError {
    erroredUpdateId?: UpdatePendingBlockSetVersionSpecsRequestId | null | undefined;
    errorMessage: string;
}
type BlockSetVersionMissingInputsConstraintFailure = Record<BlockVersionId, Array<BlockShapeId>>;
type BlockSetVersionMissingInputsConstraintFailureV2 = Array<InputBlockSetShapeId>;
interface BlockSetVersionNotFoundRationale {
    blockSetVersionId: BlockSetVersionId;
    marketplaceRid: MarketplaceRid;
}
/**
 * Range of versions. Contains all version from `from` (inclusive), to `until` (inclusive). For example, a
 * version range from version `1.3.4` to all versions with a major version of 2 would be:
 *
 * `{ from: "1.3.4", until: "2.x.x" }`
 *
 * This example will match versions such as `1.3.4`, `1.3.7`, `1.4.0`, `2.0.0`, `2.9.3`, but not `3.0.0`.
 */
interface BlockSetVersionRange {
    from: BlockSetVersion;
    until: BlockSetVersionMatcher;
}
/**
 * A non-blocking validation error indicating that the target block set version for the installation has been recalled.
 */
interface BlockSetVersionRecalled {
    blockSetVersionId: BlockSetVersionId;
    recallAnnouncements: Array<RecallVersionsAnnouncement>;
}
interface BlockSetVersionReference {
    blockSetId: BlockSetId;
    blockSetVersionId: BlockSetVersionId;
}
/**
 * This should more or less be a mirror of StoredBlockSetVersionReleaseSettings in store.yml
 */
interface BlockSetVersionReleaseMetadata {
    releaseChannels: Array<ReleaseChannel>;
}
interface BlockSetVersionStatusResponse_initializing {
    type: "initializing";
    initializing: Void;
}
interface BlockSetVersionStatusResponse_idle {
    type: "idle";
    idle: IdleBlockSetVersionStatus;
}
interface BlockSetVersionStatusResponse_materializing {
    type: "materializing";
    materializing: MaterializingBlockSetVersionStatus;
}
interface BlockSetVersionStatusResponse_finalizing {
    type: "finalizing";
    finalizing: Void;
}
interface BlockSetVersionStatusResponse_finalized {
    type: "finalized";
    finalized: FinalizedBlockSetVersionStatus;
}
interface BlockSetVersionStatusResponse_aborted {
    type: "aborted";
    aborted: BlockSetCreationAbortReason;
}
type BlockSetVersionStatusResponse = BlockSetVersionStatusResponse_initializing | BlockSetVersionStatusResponse_idle | BlockSetVersionStatusResponse_materializing | BlockSetVersionStatusResponse_finalizing | BlockSetVersionStatusResponse_finalized | BlockSetVersionStatusResponse_aborted;
interface BlockSetVersionStatusV3_initializing {
    type: "initializing";
    initializing: InitializingStatusV3;
}
interface BlockSetVersionStatusV3_idle {
    type: "idle";
    idle: IdleStatusV3;
}
interface BlockSetVersionStatusV3_processing {
    type: "processing";
    processing: ProcessingStatusV3;
}
interface BlockSetVersionStatusV3_uploading {
    type: "uploading";
    uploading: UploadingStatusV3;
}
interface BlockSetVersionStatusV3_finalizing {
    type: "finalizing";
    finalizing: FinalizingStatusV3;
}
interface BlockSetVersionStatusV3_finalized {
    type: "finalized";
    finalized: FinalizedStatusV3;
}
interface BlockSetVersionStatusV3_aborted {
    type: "aborted";
    aborted: AbortedStatusV3;
}
type BlockSetVersionStatusV3 = BlockSetVersionStatusV3_initializing | BlockSetVersionStatusV3_idle | BlockSetVersionStatusV3_processing | BlockSetVersionStatusV3_uploading | BlockSetVersionStatusV3_finalizing | BlockSetVersionStatusV3_finalized | BlockSetVersionStatusV3_aborted;
interface BlockSetVersionValidationError {
    error: BlockSetVersionValidationErrorDetail;
    errorLevel: ErrorLevel;
}
interface BlockSetVersionValidationErrorDetail_blockTypesNotGenerallyAvailableForTargetEnvironment {
    type: "blockTypesNotGenerallyAvailableForTargetEnvironment";
    blockTypesNotGenerallyAvailableForTargetEnvironment: BlockTypesNotGenerallyAvailableForTargetEnvironment;
}
interface BlockSetVersionValidationErrorDetail_duplicateOutputShapes {
    type: "duplicateOutputShapes";
    duplicateOutputShapes: BlockSetDuplicateOutputShapesError;
}
interface BlockSetVersionValidationErrorDetail_emptyOutputSpecs {
    type: "emptyOutputSpecs";
    emptyOutputSpecs: BlockSetVersionEmptyOutputSpecsError;
}
interface BlockSetVersionValidationErrorDetail_emptyTitle {
    type: "emptyTitle";
    emptyTitle: BlockSetVersionEmptyTitleError;
}
interface BlockSetVersionValidationErrorDetail_folderInputPreventsInstallingInNewProject {
    type: "folderInputPreventsInstallingInNewProject";
    folderInputPreventsInstallingInNewProject: FolderInputPreventsInstallingInNewProject;
}
interface BlockSetVersionValidationErrorDetail_indistinguishableInputShapes {
    type: "indistinguishableInputShapes";
    indistinguishableInputShapes: IndistinguishableInputShapesError;
}
interface BlockSetVersionValidationErrorDetail_inputShapeInvalidReference {
    type: "inputShapeInvalidReference";
    inputShapeInvalidReference: BlockSetInputShapeReferencingOutputShapeV2;
}
interface BlockSetVersionValidationErrorDetail_inputShapeVersionSkew {
    type: "inputShapeVersionSkew";
    inputShapeVersionSkew: BlockSetInputVersionSkew;
}
interface BlockSetVersionValidationErrorDetail_inputShapesNotMergeable {
    type: "inputShapesNotMergeable";
    inputShapesNotMergeable: BlockSetInputShapesNotMergeableError;
}
interface BlockSetVersionValidationErrorDetail_inputsAccessedInPreallocateCycle {
    type: "inputsAccessedInPreallocateCycle";
    inputsAccessedInPreallocateCycle: BlockSetInputsAccessedInPreallocateCycle;
}
interface BlockSetVersionValidationErrorDetail_inputsAccessedInReconcileCycle {
    type: "inputsAccessedInReconcileCycle";
    inputsAccessedInReconcileCycle: BlockSetInputsAccessedInReconcileCycleV2;
}
interface BlockSetVersionValidationErrorDetail_internalRecommendationVersionSkew {
    type: "internalRecommendationVersionSkew";
    internalRecommendationVersionSkew: BlockSetInternalRecommendationVersionSkew;
}
interface BlockSetVersionValidationErrorDetail_missingInternalRecommendation {
    type: "missingInternalRecommendation";
    missingInternalRecommendation: MissingInternalRecommendationError;
}
interface BlockSetVersionValidationErrorDetail_sizeLimitThresholdReachedV3 {
    type: "sizeLimitThresholdReachedV3";
    sizeLimitThresholdReachedV3: BlockSetSizeLimitThresholdReached;
}
interface BlockSetVersionValidationErrorDetail_strictFolderTrackingNoDiscoverySpec {
    type: "strictFolderTrackingNoDiscoverySpec";
    strictFolderTrackingNoDiscoverySpec: StrictFolderTrackingNoDiscoverySpec;
}
interface BlockSetVersionValidationErrorDetail_strictFolderTrackingInvalidDiscoverySpec {
    type: "strictFolderTrackingInvalidDiscoverySpec";
    strictFolderTrackingInvalidDiscoverySpec: StrictFolderTrackingInvalidDiscoverySpec;
}
interface BlockSetVersionValidationErrorDetail_strictFolderTrackingMultipleDiscoverySpecs {
    type: "strictFolderTrackingMultipleDiscoverySpecs";
    strictFolderTrackingMultipleDiscoverySpecs: StrictFolderTrackingMultipleDiscoverySpecs;
}
interface BlockSetVersionValidationErrorDetail_strictFolderTrackingInvalidProvenance {
    type: "strictFolderTrackingInvalidProvenance";
    strictFolderTrackingInvalidProvenance: StrictFolderTrackingInvalidProvenance;
}
type BlockSetVersionValidationErrorDetail = BlockSetVersionValidationErrorDetail_blockTypesNotGenerallyAvailableForTargetEnvironment | BlockSetVersionValidationErrorDetail_duplicateOutputShapes | BlockSetVersionValidationErrorDetail_emptyOutputSpecs | BlockSetVersionValidationErrorDetail_emptyTitle | BlockSetVersionValidationErrorDetail_folderInputPreventsInstallingInNewProject | BlockSetVersionValidationErrorDetail_indistinguishableInputShapes | BlockSetVersionValidationErrorDetail_inputShapeInvalidReference | BlockSetVersionValidationErrorDetail_inputShapeVersionSkew | BlockSetVersionValidationErrorDetail_inputShapesNotMergeable | BlockSetVersionValidationErrorDetail_inputsAccessedInPreallocateCycle | BlockSetVersionValidationErrorDetail_inputsAccessedInReconcileCycle | BlockSetVersionValidationErrorDetail_internalRecommendationVersionSkew | BlockSetVersionValidationErrorDetail_missingInternalRecommendation | BlockSetVersionValidationErrorDetail_sizeLimitThresholdReachedV3 | BlockSetVersionValidationErrorDetail_strictFolderTrackingNoDiscoverySpec | BlockSetVersionValidationErrorDetail_strictFolderTrackingInvalidDiscoverySpec | BlockSetVersionValidationErrorDetail_strictFolderTrackingMultipleDiscoverySpecs | BlockSetVersionValidationErrorDetail_strictFolderTrackingInvalidProvenance;
interface BlockShape_input {
    type: "input";
    input: InputShape;
}
interface BlockShape_output {
    type: "output";
    output: OutputShape;
}
type BlockShape = BlockShape_input | BlockShape_output;
interface BlockShapeBuildMetadata_shapeJobSpecsBuildMetadata {
    type: "shapeJobSpecsBuildMetadata";
    shapeJobSpecsBuildMetadata: BuildJobIds;
}
/**
 * For blocks where Marketplace has submitted a build, this provides the build metadata per block shape needed
 * to view the process of the job spec build e.g., in Job Tracker.
 * Note: build requests for shapes for a given block may be submitted in separate builds.
 */
type BlockShapeBuildMetadata = BlockShapeBuildMetadata_shapeJobSpecsBuildMetadata;
/**
 * External id for a block input shape or output shape, equivalent to a BlockInternalId.
 */
type BlockShapeId = BlockInternalId;
/**
 * Mapping information between the shapes of one block and the corresponding deduplicated BlockSetShapes
 */
type BlockShapesMappingInfo = Record<BlockShapeId, ShapeMappingInfo>;
interface BlockSizeLimitCount {
    blockLimit: number;
    numberOfBlocks: number;
}
interface BlockSpecificConfiguration_aipAgent {
    type: "aipAgent";
    aipAgent: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_appConfigAppBar {
    type: "appConfigAppBar";
    appConfigAppBar: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_appConfigAuthorizationChooserPresets {
    type: "appConfigAuthorizationChooserPresets";
    appConfigAuthorizationChooserPresets: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_appConfigAuthorizationChooserRules {
    type: "appConfigAuthorizationChooserRules";
    appConfigAuthorizationChooserRules: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_appConfigCosmos {
    type: "appConfigCosmos";
    appConfigCosmos: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_appConfigGaia {
    type: "appConfigGaia";
    appConfigGaia: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_appConfigTitanium {
    type: "appConfigTitanium";
    appConfigTitanium: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_artifactsPeerProducerProfile {
    type: "artifactsPeerProducerProfile";
    artifactsPeerProducerProfile: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_authoringRepository {
    type: "authoringRepository";
    authoringRepository: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_automation {
    type: "automation";
    automation: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_autopilotWorkbench {
    type: "autopilotWorkbench";
    autopilotWorkbench: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_blobster {
    type: "blobster";
    blobster: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_carbon {
    type: "carbon";
    carbon: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_checkpointConfig {
    type: "checkpointConfig";
    checkpointConfig: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_cipherChannel {
    type: "cipherChannel";
    cipherChannel: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_cipherLicense {
    type: "cipherLicense";
    cipherLicense: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_codeWorkspace {
    type: "codeWorkspace";
    codeWorkspace: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_compass {
    type: "compass";
    compass: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_contour {
    type: "contour";
    contour: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_dataHealth {
    type: "dataHealth";
    dataHealth: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_deployedApp {
    type: "deployedApp";
    deployedApp: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_directDatasource {
    type: "directDatasource";
    directDatasource: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_eddieEdgePipeline {
    type: "eddieEdgePipeline";
    eddieEdgePipeline: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_eddieGroup {
    type: "eddieGroup";
    eddieGroup: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_editsView {
    type: "editsView";
    editsView: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_evaluationSuite {
    type: "evaluationSuite";
    evaluationSuite: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_foundryPeerProducerProfile {
    type: "foundryPeerProducerProfile";
    foundryPeerProducerProfile: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_functionConfigurations {
    type: "functionConfigurations";
    functionConfigurations: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_functionPackageConfiguration {
    type: "functionPackageConfiguration";
    functionPackageConfiguration: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_functions {
    type: "functions";
    functions: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_logic {
    type: "logic";
    logic: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_machinery {
    type: "machinery";
    machinery: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_magritteConnector {
    type: "magritteConnector";
    magritteConnector: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_magritteExport {
    type: "magritteExport";
    magritteExport: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_magritteSource {
    type: "magritteSource";
    magritteSource: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_mapRenderingService {
    type: "mapRenderingService";
    mapRenderingService: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_mediaSet {
    type: "mediaSet";
    mediaSet: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_model {
    type: "model";
    model: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_modelStudio {
    type: "modelStudio";
    modelStudio: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_monitoringView {
    type: "monitoringView";
    monitoringView: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_namedCredential {
    type: "namedCredential";
    namedCredential: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_networkEgressPolicy {
    type: "networkEgressPolicy";
    networkEgressPolicy: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_notepad {
    type: "notepad";
    notepad: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_objectSet {
    type: "objectSet";
    objectSet: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_objectView {
    type: "objectView";
    objectView: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_ontology {
    type: "ontology";
    ontology: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_ontologySdk {
    type: "ontologySdk";
    ontologySdk: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_peerProfile {
    type: "peerProfile";
    peerProfile: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_podModel {
    type: "podModel";
    podModel: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_quiver {
    type: "quiver";
    quiver: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_resourceUpdates {
    type: "resourceUpdates";
    resourceUpdates: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_restrictedView {
    type: "restrictedView";
    restrictedView: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_rosetta {
    type: "rosetta";
    rosetta: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_satelliteImageryModel {
    type: "satelliteImageryModel";
    satelliteImageryModel: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_savedSearchAroundV2 {
    type: "savedSearchAroundV2";
    savedSearchAroundV2: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_schedule {
    type: "schedule";
    schedule: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_slate {
    type: "slate";
    slate: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_solutionDesign {
    type: "solutionDesign";
    solutionDesign: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_staticDataset {
    type: "staticDataset";
    staticDataset: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_streamDataset {
    type: "streamDataset";
    streamDataset: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_storedProcedure {
    type: "storedProcedure";
    storedProcedure: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_taurusWorkflow {
    type: "taurusWorkflow";
    taurusWorkflow: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_templates {
    type: "templates";
    templates: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_timeSeriesSync {
    type: "timeSeriesSync";
    timeSeriesSync: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_thirdPartyApplication {
    type: "thirdPartyApplication";
    thirdPartyApplication: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_transforms {
    type: "transforms";
    transforms: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_valueType {
    type: "valueType";
    valueType: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_versionedObjectSet {
    type: "versionedObjectSet";
    versionedObjectSet: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_vertex {
    type: "vertex";
    vertex: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_virtualTable {
    type: "virtualTable";
    virtualTable: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_vortex {
    type: "vortex";
    vortex: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_walkthrough {
    type: "walkthrough";
    walkthrough: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_webhooks {
    type: "webhooks";
    webhooks: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_widgetSet {
    type: "widgetSet";
    widgetSet: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_workbenchTemplate {
    type: "workbenchTemplate";
    workbenchTemplate: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_workflowBuilderGraph {
    type: "workflowBuilderGraph";
    workflowBuilderGraph: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_workflowGraph {
    type: "workflowGraph";
    workflowGraph: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_sqlWorksheet {
    type: "sqlWorksheet";
    sqlWorksheet: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_workshop {
    type: "workshop";
    workshop: DefaultBlockSpecificConfiguration;
}
interface BlockSpecificConfiguration_writeback {
    type: "writeback";
    writeback: DefaultBlockSpecificConfiguration;
}
/**
 * The type of the block is implicitly defined by the type of the block specification.
 *
 * Note that this should contain the minimum amount of information necessary for the frontend
 * to display nice things and no more! Any non-empty block specific configuration will need
 * justification/will be reviewed by the foundry marketplace team.
 */
type BlockSpecificConfiguration = BlockSpecificConfiguration_aipAgent | BlockSpecificConfiguration_appConfigAppBar | BlockSpecificConfiguration_appConfigAuthorizationChooserPresets | BlockSpecificConfiguration_appConfigAuthorizationChooserRules | BlockSpecificConfiguration_appConfigCosmos | BlockSpecificConfiguration_appConfigGaia | BlockSpecificConfiguration_appConfigTitanium | BlockSpecificConfiguration_artifactsPeerProducerProfile | BlockSpecificConfiguration_authoringRepository | BlockSpecificConfiguration_automation | BlockSpecificConfiguration_autopilotWorkbench | BlockSpecificConfiguration_blobster | BlockSpecificConfiguration_carbon | BlockSpecificConfiguration_checkpointConfig | BlockSpecificConfiguration_cipherChannel | BlockSpecificConfiguration_cipherLicense | BlockSpecificConfiguration_codeWorkspace | BlockSpecificConfiguration_compass | BlockSpecificConfiguration_contour | BlockSpecificConfiguration_dataHealth | BlockSpecificConfiguration_deployedApp | BlockSpecificConfiguration_directDatasource | BlockSpecificConfiguration_eddieEdgePipeline | BlockSpecificConfiguration_eddieGroup | BlockSpecificConfiguration_editsView | BlockSpecificConfiguration_evaluationSuite | BlockSpecificConfiguration_foundryPeerProducerProfile | BlockSpecificConfiguration_functionConfigurations | BlockSpecificConfiguration_functionPackageConfiguration | BlockSpecificConfiguration_functions | BlockSpecificConfiguration_logic | BlockSpecificConfiguration_machinery | BlockSpecificConfiguration_magritteConnector | BlockSpecificConfiguration_magritteExport | BlockSpecificConfiguration_magritteSource | BlockSpecificConfiguration_mapRenderingService | BlockSpecificConfiguration_mediaSet | BlockSpecificConfiguration_model | BlockSpecificConfiguration_modelStudio | BlockSpecificConfiguration_monitoringView | BlockSpecificConfiguration_namedCredential | BlockSpecificConfiguration_networkEgressPolicy | BlockSpecificConfiguration_notepad | BlockSpecificConfiguration_objectSet | BlockSpecificConfiguration_objectView | BlockSpecificConfiguration_ontology | BlockSpecificConfiguration_ontologySdk | BlockSpecificConfiguration_peerProfile | BlockSpecificConfiguration_podModel | BlockSpecificConfiguration_quiver | BlockSpecificConfiguration_resourceUpdates | BlockSpecificConfiguration_restrictedView | BlockSpecificConfiguration_rosetta | BlockSpecificConfiguration_satelliteImageryModel | BlockSpecificConfiguration_savedSearchAroundV2 | BlockSpecificConfiguration_schedule | BlockSpecificConfiguration_slate | BlockSpecificConfiguration_solutionDesign | BlockSpecificConfiguration_staticDataset | BlockSpecificConfiguration_streamDataset | BlockSpecificConfiguration_storedProcedure | BlockSpecificConfiguration_taurusWorkflow | BlockSpecificConfiguration_templates | BlockSpecificConfiguration_timeSeriesSync | BlockSpecificConfiguration_thirdPartyApplication | BlockSpecificConfiguration_transforms | BlockSpecificConfiguration_valueType | BlockSpecificConfiguration_versionedObjectSet | BlockSpecificConfiguration_vertex | BlockSpecificConfiguration_virtualTable | BlockSpecificConfiguration_vortex | BlockSpecificConfiguration_walkthrough | BlockSpecificConfiguration_webhooks | BlockSpecificConfiguration_widgetSet | BlockSpecificConfiguration_workbenchTemplate | BlockSpecificConfiguration_workflowBuilderGraph | BlockSpecificConfiguration_workflowGraph | BlockSpecificConfiguration_sqlWorksheet | BlockSpecificConfiguration_workshop | BlockSpecificConfiguration_writeback;
interface BlockSpecificCreateRequest_aipAgent {
    type: "aipAgent";
    aipAgent: AipAgentCreateBlockRequest;
}
interface BlockSpecificCreateRequest_appConfigAppBar {
    type: "appConfigAppBar";
    appConfigAppBar: AppConfigCreateBlockRequest;
}
interface BlockSpecificCreateRequest_appConfigAuthorizationChooserPresets {
    type: "appConfigAuthorizationChooserPresets";
    appConfigAuthorizationChooserPresets: AppConfigCreateBlockRequest;
}
interface BlockSpecificCreateRequest_appConfigAuthorizationChooserRules {
    type: "appConfigAuthorizationChooserRules";
    appConfigAuthorizationChooserRules: AppConfigCreateBlockRequest;
}
interface BlockSpecificCreateRequest_appConfigCosmos {
    type: "appConfigCosmos";
    appConfigCosmos: AppConfigCreateBlockRequest;
}
interface BlockSpecificCreateRequest_appConfigGaia {
    type: "appConfigGaia";
    appConfigGaia: AppConfigCreateBlockRequest;
}
interface BlockSpecificCreateRequest_appConfigTitanium {
    type: "appConfigTitanium";
    appConfigTitanium: AppConfigCreateBlockRequest;
}
interface BlockSpecificCreateRequest_artifactsPeerProducerProfile {
    type: "artifactsPeerProducerProfile";
    artifactsPeerProducerProfile: ArtifactsPeerProducerProfileCreateBlockRequest;
}
interface BlockSpecificCreateRequest_authoringRepository {
    type: "authoringRepository";
    authoringRepository: AuthoringRepositoryCreateBlockRequest;
}
interface BlockSpecificCreateRequest_authoringRepositoryV2 {
    type: "authoringRepositoryV2";
    authoringRepositoryV2: AuthoringRepositoryCreateBlockRequestV2;
}
interface BlockSpecificCreateRequest_automation {
    type: "automation";
    automation: AutomationCreateBlockRequest;
}
interface BlockSpecificCreateRequest_autopilotWorkbench {
    type: "autopilotWorkbench";
    autopilotWorkbench: AutopilotWorkbenchCreateBlockRequest;
}
interface BlockSpecificCreateRequest_blobster {
    type: "blobster";
    blobster: BlobsterCreateBlockRequest;
}
interface BlockSpecificCreateRequest_carbon {
    type: "carbon";
    carbon: CarbonCreateBlockRequest;
}
interface BlockSpecificCreateRequest_checkpointConfig {
    type: "checkpointConfig";
    checkpointConfig: CheckpointConfigCreateBlockRequest;
}
interface BlockSpecificCreateRequest_cipherChannel {
    type: "cipherChannel";
    cipherChannel: CipherChannelCreateBlockRequest;
}
interface BlockSpecificCreateRequest_cipherLicense {
    type: "cipherLicense";
    cipherLicense: CipherLicenseCreateBlockRequest;
}
interface BlockSpecificCreateRequest_codeWorkspace {
    type: "codeWorkspace";
    codeWorkspace: CodeWorkspaceCreateBlockRequest;
}
interface BlockSpecificCreateRequest_compass {
    type: "compass";
    compass: CompassCreateBlockRequest;
}
interface BlockSpecificCreateRequest_contour {
    type: "contour";
    contour: ContourCreateBlockRequest;
}
interface BlockSpecificCreateRequest_dataHealth {
    type: "dataHealth";
    dataHealth: DataHealthCheckCreateBlockRequest;
}
interface BlockSpecificCreateRequest_deployedApp {
    type: "deployedApp";
    deployedApp: DeployedAppCreateBlockRequest;
}
interface BlockSpecificCreateRequest_directDatasource {
    type: "directDatasource";
    directDatasource: DirectDatasourceCreateBlockRequest;
}
interface BlockSpecificCreateRequest_eddie {
    type: "eddie";
    eddie: EddieCreateBlockRequest;
}
interface BlockSpecificCreateRequest_eddieEdgePipeline {
    type: "eddieEdgePipeline";
    eddieEdgePipeline: EddieEdgePipelineCreateBlockRequest;
}
interface BlockSpecificCreateRequest_editsView {
    type: "editsView";
    editsView: EditsViewCreateBlockRequest;
}
interface BlockSpecificCreateRequest_evaluationSuite {
    type: "evaluationSuite";
    evaluationSuite: EvaluationSuiteCreateBlockRequest;
}
interface BlockSpecificCreateRequest_foundryPeerProducerProfile {
    type: "foundryPeerProducerProfile";
    foundryPeerProducerProfile: FoundryPeerProducerProfileCreateBlockRequest;
}
interface BlockSpecificCreateRequest_functionConfigurations {
    type: "functionConfigurations";
    functionConfigurations: FunctionConfigurationsCreateBlockRequest;
}
interface BlockSpecificCreateRequest_functionPackageConfiguration {
    type: "functionPackageConfiguration";
    functionPackageConfiguration: FunctionPackageConfigurationCreateBlockRequest;
}
interface BlockSpecificCreateRequest_functions {
    type: "functions";
    functions: FunctionsCreateBlockRequest;
}
interface BlockSpecificCreateRequest_logic {
    type: "logic";
    logic: LogicCreateBlockRequest;
}
interface BlockSpecificCreateRequest_machinery {
    type: "machinery";
    machinery: MachineryCreateBlockRequest;
}
interface BlockSpecificCreateRequest_magritteConnector {
    type: "magritteConnector";
    magritteConnector: MagritteConnectorCreateBlockRequest;
}
interface BlockSpecificCreateRequest_magritteExport {
    type: "magritteExport";
    magritteExport: MagritteExportCreateBlockRequest;
}
interface BlockSpecificCreateRequest_magritteSource {
    type: "magritteSource";
    magritteSource: MagritteSourceCreateBlockRequest;
}
interface BlockSpecificCreateRequest_mediaSet {
    type: "mediaSet";
    mediaSet: MediaSetCreateBlockRequest;
}
interface BlockSpecificCreateRequest_model {
    type: "model";
    model: ModelCreateBlockRequest;
}
interface BlockSpecificCreateRequest_modelStudio {
    type: "modelStudio";
    modelStudio: ModelStudioCreateBlockRequest;
}
interface BlockSpecificCreateRequest_monitoringView {
    type: "monitoringView";
    monitoringView: MonitoringViewCreateBlockRequest;
}
interface BlockSpecificCreateRequest_mapRenderingService {
    type: "mapRenderingService";
    mapRenderingService: MapRenderingServiceCreateBlockRequest;
}
interface BlockSpecificCreateRequest_namedCredential {
    type: "namedCredential";
    namedCredential: NamedCredentialCreateBlockRequest;
}
interface BlockSpecificCreateRequest_networkEgressPolicy {
    type: "networkEgressPolicy";
    networkEgressPolicy: NetworkEgressPolicyCreateBlockRequest;
}
interface BlockSpecificCreateRequest_notepad {
    type: "notepad";
    notepad: NotepadCreateBlockRequest;
}
interface BlockSpecificCreateRequest_notepadTemplate {
    type: "notepadTemplate";
    notepadTemplate: NotepadTemplateCreateBlockRequest;
}
interface BlockSpecificCreateRequest_objectSet {
    type: "objectSet";
    objectSet: ObjectSetCreateBlockRequest;
}
interface BlockSpecificCreateRequest_objectView {
    type: "objectView";
    objectView: ObjectViewCreateBlockRequest;
}
interface BlockSpecificCreateRequest_ontology {
    type: "ontology";
    ontology: OntologyCreateBlockRequest;
}
interface BlockSpecificCreateRequest_peerProfile {
    type: "peerProfile";
    peerProfile: PeerProfileCreateBlockRequest;
}
interface BlockSpecificCreateRequest_quiver {
    type: "quiver";
    quiver: QuiverCreateBlockRequest;
}
interface BlockSpecificCreateRequest_resourceUpdates {
    type: "resourceUpdates";
    resourceUpdates: ResourceUpdatesCreateBlockRequest;
}
interface BlockSpecificCreateRequest_restrictedView {
    type: "restrictedView";
    restrictedView: RestrictedViewCreateBlockRequest;
}
interface BlockSpecificCreateRequest_rosetta {
    type: "rosetta";
    rosetta: RosettaCreateBlockRequest;
}
interface BlockSpecificCreateRequest_satelliteImageryModel {
    type: "satelliteImageryModel";
    satelliteImageryModel: SatelliteImageryModelCreateBlockRequest;
}
interface BlockSpecificCreateRequest_schedule {
    type: "schedule";
    schedule: ScheduleCreateBlockRequest;
}
interface BlockSpecificCreateRequest_taurus {
    type: "taurus";
    taurus: TaurusCreateBlockRequest;
}
interface BlockSpecificCreateRequest_ontologySdk {
    type: "ontologySdk";
    ontologySdk: OntologySdkCreateBlockRequest;
}
interface BlockSpecificCreateRequest_ontologySdkV2 {
    type: "ontologySdkV2";
    ontologySdkV2: OntologySdkCreateBlockRequestV2;
}
interface BlockSpecificCreateRequest_savedSearchAroundV2 {
    type: "savedSearchAroundV2";
    savedSearchAroundV2: SavedSearchAroundV2CreateBlockRequest;
}
interface BlockSpecificCreateRequest_slate {
    type: "slate";
    slate: SlateCreateBlockRequest;
}
interface BlockSpecificCreateRequest_solutionDesign {
    type: "solutionDesign";
    solutionDesign: SolutionDesignCreateBlockRequest;
}
interface BlockSpecificCreateRequest_staticDataset {
    type: "staticDataset";
    staticDataset: StaticDatasetCreateBlockRequest;
}
interface BlockSpecificCreateRequest_storedProcedure {
    type: "storedProcedure";
    storedProcedure: StoredProcedureCreateBlockRequest;
}
interface BlockSpecificCreateRequest_streamDataset {
    type: "streamDataset";
    streamDataset: StreamDatasetCreateBlockRequest;
}
interface BlockSpecificCreateRequest_templates {
    type: "templates";
    templates: TemplatesCreateBlockRequest;
}
interface BlockSpecificCreateRequest_timeSeriesSync {
    type: "timeSeriesSync";
    timeSeriesSync: TimeSeriesSyncCreateBlockRequest;
}
interface BlockSpecificCreateRequest_thirdPartyApplication {
    type: "thirdPartyApplication";
    thirdPartyApplication: ThirdPartyApplicationCreateBlockRequest;
}
interface BlockSpecificCreateRequest_transforms {
    type: "transforms";
    transforms: TransformsCreateBlockRequest;
}
interface BlockSpecificCreateRequest_valueType {
    type: "valueType";
    valueType: ValueTypeCreateBlockRequest;
}
interface BlockSpecificCreateRequest_versionedObjectSet {
    type: "versionedObjectSet";
    versionedObjectSet: VersionedObjectSetCreateBlockRequest;
}
interface BlockSpecificCreateRequest_vertex {
    type: "vertex";
    vertex: VertexCreateBlockRequest;
}
interface BlockSpecificCreateRequest_virtualTable {
    type: "virtualTable";
    virtualTable: VirtualTableCreateBlockRequest;
}
interface BlockSpecificCreateRequest_vortex {
    type: "vortex";
    vortex: VortexCreateBlockRequest;
}
interface BlockSpecificCreateRequest_walkthrough {
    type: "walkthrough";
    walkthrough: WalkthroughCreateBlockRequest;
}
interface BlockSpecificCreateRequest_webhooks {
    type: "webhooks";
    webhooks: WebhooksCreateBlockRequest;
}
interface BlockSpecificCreateRequest_widgetSet {
    type: "widgetSet";
    widgetSet: WidgetSetCreateBlockRequest;
}
interface BlockSpecificCreateRequest_workbenchTemplate {
    type: "workbenchTemplate";
    workbenchTemplate: WorkbenchTemplateCreateBlockRequest;
}
interface BlockSpecificCreateRequest_workflowBuilderGraph {
    type: "workflowBuilderGraph";
    workflowBuilderGraph: WorkflowBuilderGraphCreateBlockRequest;
}
interface BlockSpecificCreateRequest_workflowGraph {
    type: "workflowGraph";
    workflowGraph: WorkflowGraphCreateBlockRequest;
}
interface BlockSpecificCreateRequest_sqlWorksheet {
    type: "sqlWorksheet";
    sqlWorksheet: SqlWorksheetCreateBlockRequest;
}
interface BlockSpecificCreateRequest_workshop {
    type: "workshop";
    workshop: WorkshopCreateBlockRequest;
}
interface BlockSpecificCreateRequest_writeback {
    type: "writeback";
    writeback: WritebackCreateBlockRequest;
}
/**
 * Request for creating a new version of a block of a specific type.
 */
type BlockSpecificCreateRequest = BlockSpecificCreateRequest_aipAgent | BlockSpecificCreateRequest_appConfigAppBar | BlockSpecificCreateRequest_appConfigAuthorizationChooserPresets | BlockSpecificCreateRequest_appConfigAuthorizationChooserRules | BlockSpecificCreateRequest_appConfigCosmos | BlockSpecificCreateRequest_appConfigGaia | BlockSpecificCreateRequest_appConfigTitanium | BlockSpecificCreateRequest_artifactsPeerProducerProfile | BlockSpecificCreateRequest_authoringRepository | BlockSpecificCreateRequest_authoringRepositoryV2 | BlockSpecificCreateRequest_automation | BlockSpecificCreateRequest_autopilotWorkbench | BlockSpecificCreateRequest_blobster | BlockSpecificCreateRequest_carbon | BlockSpecificCreateRequest_checkpointConfig | BlockSpecificCreateRequest_cipherChannel | BlockSpecificCreateRequest_cipherLicense | BlockSpecificCreateRequest_codeWorkspace | BlockSpecificCreateRequest_compass | BlockSpecificCreateRequest_contour | BlockSpecificCreateRequest_dataHealth | BlockSpecificCreateRequest_deployedApp | BlockSpecificCreateRequest_directDatasource | BlockSpecificCreateRequest_eddie | BlockSpecificCreateRequest_eddieEdgePipeline | BlockSpecificCreateRequest_editsView | BlockSpecificCreateRequest_evaluationSuite | BlockSpecificCreateRequest_foundryPeerProducerProfile | BlockSpecificCreateRequest_functionConfigurations | BlockSpecificCreateRequest_functionPackageConfiguration | BlockSpecificCreateRequest_functions | BlockSpecificCreateRequest_logic | BlockSpecificCreateRequest_machinery | BlockSpecificCreateRequest_magritteConnector | BlockSpecificCreateRequest_magritteExport | BlockSpecificCreateRequest_magritteSource | BlockSpecificCreateRequest_mediaSet | BlockSpecificCreateRequest_model | BlockSpecificCreateRequest_modelStudio | BlockSpecificCreateRequest_monitoringView | BlockSpecificCreateRequest_mapRenderingService | BlockSpecificCreateRequest_namedCredential | BlockSpecificCreateRequest_networkEgressPolicy | BlockSpecificCreateRequest_notepad | BlockSpecificCreateRequest_notepadTemplate | BlockSpecificCreateRequest_objectSet | BlockSpecificCreateRequest_objectView | BlockSpecificCreateRequest_ontology | BlockSpecificCreateRequest_peerProfile | BlockSpecificCreateRequest_quiver | BlockSpecificCreateRequest_resourceUpdates | BlockSpecificCreateRequest_restrictedView | BlockSpecificCreateRequest_rosetta | BlockSpecificCreateRequest_satelliteImageryModel | BlockSpecificCreateRequest_schedule | BlockSpecificCreateRequest_taurus | BlockSpecificCreateRequest_ontologySdk | BlockSpecificCreateRequest_ontologySdkV2 | BlockSpecificCreateRequest_savedSearchAroundV2 | BlockSpecificCreateRequest_slate | BlockSpecificCreateRequest_solutionDesign | BlockSpecificCreateRequest_staticDataset | BlockSpecificCreateRequest_storedProcedure | BlockSpecificCreateRequest_streamDataset | BlockSpecificCreateRequest_templates | BlockSpecificCreateRequest_timeSeriesSync | BlockSpecificCreateRequest_thirdPartyApplication | BlockSpecificCreateRequest_transforms | BlockSpecificCreateRequest_valueType | BlockSpecificCreateRequest_versionedObjectSet | BlockSpecificCreateRequest_vertex | BlockSpecificCreateRequest_virtualTable | BlockSpecificCreateRequest_vortex | BlockSpecificCreateRequest_walkthrough | BlockSpecificCreateRequest_webhooks | BlockSpecificCreateRequest_widgetSet | BlockSpecificCreateRequest_workbenchTemplate | BlockSpecificCreateRequest_workflowBuilderGraph | BlockSpecificCreateRequest_workflowGraph | BlockSpecificCreateRequest_sqlWorksheet | BlockSpecificCreateRequest_workshop | BlockSpecificCreateRequest_writeback;
/**
 * Mirror enum for the `BlockSpecificConfiguration` union.
 */
type BlockType = "AIP_AGENT" | "APP_CONFIG_APP_BAR" | "APP_CONFIG_AUTHORIZATION_CHOOSER_PRESETS" | "APP_CONFIG_AUTHORIZATION_CHOOSER_RULES" | "APP_CONFIG_COSMOS" | "APP_CONFIG_GAIA" | "APP_CONFIG_TITANIUM" | "ARTIFACTS_PEER_PRODUCER_PROFILE" | "AUTHORING_REPOSITORY" | "AUTOMATION" | "AUTOPILOT_WORKBENCH" | "BLOBSTER" | "CARBON" | "CHECKPOINT_CONFIG" | "CIPHER_CHANNEL" | "CIPHER_LICENSE" | "CODE_WORKSPACE" | "COMPASS" | "CONTOUR" | "DATA_HEALTH" | "DEPLOYED_APP" | "DIRECT_DATASOURCE" | "EDDIE_EDGE_PIPELINE" | "EDDIE_GROUP" | "EDITS_VIEW" | "EVALUATION_SUITE" | "FOUNDRY_PEER_PRODUCER_PROFILE" | "FUNCTION_CONFIGURATIONS" | "FUNCTION_PACKAGE_CONFIGURATION" | "FUNCTIONS" | "LOGIC" | "MACHINERY" | "MAGRITTE_CONNECTOR" | "MAGRITTE_EXPORT" | "MAGRITTE_SOURCE" | "MEDIA_SET" | "MODEL" | "MODEL_STUDIO" | "MONITORING_VIEW" | "NAMED_CREDENTIAL" | "NETWORK_EGRESS_POLICY" | "NOTEPAD" | "OBJECT_SET" | "OBJECT_VIEW" | "MAP_RENDERING_SERVICE" | "ONTOLOGY" | "ONTOLOGY_SDK" | "PEER_PROFILE" | "POD_MODEL" | "QUIVER" | "RESOURCE_UPDATES" | "RESTRICTED_VIEW" | "ROSETTA" | "SATELLITE_IMAGERY_MODEL" | "SAVED_SEARCH_AROUND_V2" | "SCHEDULE" | "SLATE" | "SOLUTION_DESIGN" | "STATIC_DATASET" | "STREAM_DATASET" | "STORED_PROCEDURE" | "TAURUS_WORKFLOW" | "TEMPLATES" | "TIME_SERIES_SYNC" | "THIRD_PARTY_APPLICATION" | "TRANSFORMS" | "VALUE_TYPE" | "VERSIONED_OBJECT_SET" | "VERTEX" | "VIRTUAL_TABLE" | "VORTEX" | "WALKTHROUGH" | "WEBHOOKS" | "WIDGET_SET" | "WORKBENCH_TEMPLATE" | "WORKFLOW_BUILDER_GRAPH" | "WORKFLOW_GRAPH" | "SQL_WORKSHEET" | "WORKSHOP" | "WRITEBACK";
/**
 * A set of outputs on a given Marketplace product are integrated by block types which may not GA compatible
 * with the Marketplace product's configured target environment.
 */
interface BlockTypesNotGenerallyAvailableForTargetEnvironment {
    blockTypes: Array<BlockType>;
    targetEnvironment: TargetEnvironment;
}
/**
 * All metadata for a particular (version of a) block. That is, all parts of the block other than the block data,
 * which is referenced here but stored elsewhere (artifacts).
 */
interface BlockV1 {
    about: LocalizedTitleAndDescription;
    blockData: Record<BlockDataId, SerializedDataLocator>;
    configuration: BlockSpecificConfiguration;
    inputGroups: Record<InputGroupId, InputGroup>;
    inputMetadata: Record<BlockShapeId, InputShapeMetadata>;
    inputs: Record<BlockShapeId, InputShape>;
    knownIdentifiers: Record<KnownIdentifier, BlockInternalId>;
    outputs: Record<BlockShapeId, OutputShape>;
    recommendations: Record<BlockRecommendationId, BlockRecommendation>;
}
type BlockVersion = string;
interface BlockVersionCreationErrorStatus {
    error: BlockCreationError;
}
interface BlockVersionCreationPendingStatus_waitingForData {
    type: "waitingForData";
    waitingForData: Void;
}
interface BlockVersionCreationPendingStatus_waitingForFinalization {
    type: "waitingForFinalization";
    waitingForFinalization: Void;
}
type BlockVersionCreationPendingStatus = BlockVersionCreationPendingStatus_waitingForData | BlockVersionCreationPendingStatus_waitingForFinalization;
interface BlockVersionCreationStatus_pending {
    type: "pending";
    pending: BlockVersionCreationPendingStatus;
}
interface BlockVersionCreationStatus_success {
    type: "success";
    success: Void;
}
interface BlockVersionCreationStatus_error {
    type: "error";
    error: BlockVersionCreationErrorStatus;
}
type BlockVersionCreationStatus = BlockVersionCreationStatus_pending | BlockVersionCreationStatus_success | BlockVersionCreationStatus_error;
/**
 * Unique identifier for a particular version of a block. That is, 1:1 with (BlockId, BlockVersion) tuples.
 */
type BlockVersionId = string;
interface BlockVersionIdDoesNotExist {
    blockVersion: BlockVersionId;
}
/**
 * Matches ranges of versions. Use an `x` instead of a version number to represent wildcards. Once one level
 * has a wildcard, all subsequent ones must be as well (i.e. `1.x.4` is not supported, while `1.x.x` is). Any
 * missing levels are assumed to be wildcards (i.e. `1.x` is equivalent to `1.x.x`).
 */
type BlockVersionMatcher = string;
/**
 * Range of versions. Contains all version from `from` (inclusive), to `until` (inclusive). For example, a
 * version range from version `1.3.4` to all versions with a major version of 2 would be:
 *
 * `{ from: "1.3.4", until: "2.x.x" }`
 *
 * This example will match versions such as `1.3.4`, `1.3.7`, `1.4.0`, `2.0.0`, `2.9.3`, but not `3.0.0`.
 */
interface BlockVersionRange {
    from: BlockVersion;
    until: BlockVersionMatcher;
}
interface BmpFormat {
}
/**
 * BooleanListType specifies that this parameter must be a list of Booleans.
 */
interface BooleanListType {
}
/**
 * BooleanType specifies that this parameter must be a Boolean.
 */
interface BooleanType {
}
type BooleanValue = boolean;
type Branch = string;
interface BuildCancelled {
}
interface BuildError {
}
/**
 * A build was submitted as part of the install of this blocked, but this build failed or was cancelled.
 */
interface BuildFailure {
    buildRid: BuildRid;
    buildStatus: string;
    shapeJobRids: Record<BlockShapeId, JobRid>;
}
interface BuildingInstallPendingStatus {
    blockShapeBuildMetadata: Record<BlockShapeId, BlockShapeBuildMetadata>;
    buildsAndIndexingIds: Record<BlockShapeId, BuildsAndIndexingIds>;
}
interface BuildJobIds {
    buildRid: BuildRid;
    jobRid: JobRid;
}
/**
 * A build was requested but the marketplace job failed during orchestration of this build.
 */
interface BuildOrchestrationFailure {
    buildRid?: BuildRid | null | undefined;
    message: string;
}
type BuildRid = string;
/**
 * For blocks where Marketplace must track state after reconcile, this could be either or both of submitting a
 * build to build2 or tracking the indexing state of an object/many-to-many link in Funnel.
 */
interface BuildsAndIndexingIds {
    buildJobIds?: BuildJobIds | null | undefined;
    indexableEntityIds?: IndexableEntityIds | null | undefined;
}
interface BuildSettings {
    buildOption: InstallationJobBuildOption;
}
/**
 * The time marketplace saw the build(s) finish. This time is updated for both successful and failed builds.
 */
type BuildsFinishedAtTimestamp = string;
interface BuildTimedOut {
}
/**
 * A build was submitted as part of the install of this blocked, but this build did not succeed within the
 * timeout period defined by Marketplace for an installation build.
 */
interface BuildTimeout {
    buildRid: BuildRid;
    buildStartedTime: string;
    buildStatus: string;
    shapeJobRids: Record<BlockShapeId, JobRid>;
}
/**
 * The build tool used to produce this OAC bundle
 */
type BuildToolOrigin = "GRADLE" | "CLI";
interface BulkCreateBlockSetVersionRequest {
    requests: Array<CreateBlockSetVersionRequest>;
}
interface BulkCreateBlockSetVersionResponse {
    responses: Array<CreateBlockSetVersionResponse>;
}
interface BulkImportBlockSetsDetailsFailure {
    blockSetVersions: Array<BlockSetVersionId>;
    bundleDigest: Sha256Hash;
    maybeSigningKeyId?: SigningKeyId | null | undefined;
    targetMarketplaceRid: MarketplaceRid;
}
interface BulkImportBlockSetsDetailsSuccess {
    bundleDigest: Sha256Hash;
    importedBlockSets: Array<ImportBlockSetResponse>;
    targetMarketplaceRid: MarketplaceRid;
}
interface BulkImportBlockSetsResponse {
    responses: Array<ImportBlockSetResponse>;
    responseV2: BulkImportBlockSetsResponseV2;
}
interface BulkImportBlockSetsResponseV2_success {
    type: "success";
    success: BulkImportBlockSetsDetailsSuccess;
}
interface BulkImportBlockSetsResponseV2_unsignedBundle {
    type: "unsignedBundle";
    unsignedBundle: BulkImportBlockSetsDetailsFailure;
}
interface BulkImportBlockSetsResponseV2_publicKeyNotRecognized {
    type: "publicKeyNotRecognized";
    publicKeyNotRecognized: BulkImportBlockSetsDetailsFailure;
}
interface BulkImportBlockSetsResponseV2_tamperedBundle {
    type: "tamperedBundle";
    tamperedBundle: BulkImportBlockSetsDetailsFailure;
}
interface BulkImportBlockSetsResponseV2_invalidProductPermissions {
    type: "invalidProductPermissions";
    invalidProductPermissions: BulkImportBlockSetsDetailsFailure;
}
interface BulkImportBlockSetsResponseV2_malformedFile {
    type: "malformedFile";
    malformedFile: Void;
}
type BulkImportBlockSetsResponseV2 = BulkImportBlockSetsResponseV2_success | BulkImportBlockSetsResponseV2_unsignedBundle | BulkImportBlockSetsResponseV2_publicKeyNotRecognized | BulkImportBlockSetsResponseV2_tamperedBundle | BulkImportBlockSetsResponseV2_invalidProductPermissions | BulkImportBlockSetsResponseV2_malformedFile;
interface CancelFinalizeDraftGroupRequest {
}
interface CancelFinalizeDraftGroupResponse {
}
interface CancelInstallationJobAllowance_allowed {
    type: "allowed";
    allowed: Void;
}
interface CancelInstallationJobAllowance_disallowed {
    type: "disallowed";
    disallowed: CancelInstallationJobDisallowed;
}
type CancelInstallationJobAllowance = CancelInstallationJobAllowance_allowed | CancelInstallationJobAllowance_disallowed;
interface CancelInstallationJobDisallowed {
    rationale: CancelInstallationJobPermissionDeniedRationale;
}
interface CancelInstallationJobPermissionDeniedRationale {
    installationJobRids: Array<InstallBlocksJobRid>;
}
/**
 * A cancellation of a recall announcement already made by the packager. This announcement
 * is used by Marketplace to to unblock target versions from being installed, and cancelling roll-offs for
 * installers based on the specified roll-off strategy.
 */
interface CancelRecallAnnouncement {
    id: RecallId;
    message: string;
    targetId: RecallId;
}
interface CancelRecallRequest {
    message: string;
    targetRecallId: RecallId;
}
interface CancelRecallResponse {
    recallId: RecallId;
}
interface CanCreateBlockVersionWithOutputResult_ok {
    type: "ok";
    ok: CanCreateBlockVersionWithOutputResultOk;
}
interface CanCreateBlockVersionWithOutputResult_error {
    type: "error";
    error: CanCreateBlockVersionWithOutputResultError;
}
type CanCreateBlockVersionWithOutputResult = CanCreateBlockVersionWithOutputResult_ok | CanCreateBlockVersionWithOutputResult_error;
interface CanCreateBlockVersionWithOutputResultError_resourcePermissionDenied {
    type: "resourcePermissionDenied";
    resourcePermissionDenied: ResourcePermissionDenied;
}
interface CanCreateBlockVersionWithOutputResultError_notAuthorizedToUseMarkings {
    type: "notAuthorizedToUseMarkings";
    notAuthorizedToUseMarkings: NotAuthorizedToUseMarkings;
}
interface CanCreateBlockVersionWithOutputResultError_notAuthorizedToDeclassify {
    type: "notAuthorizedToDeclassify";
    notAuthorizedToDeclassify: NotAuthorizedToDeclassify;
}
type CanCreateBlockVersionWithOutputResultError = CanCreateBlockVersionWithOutputResultError_resourcePermissionDenied | CanCreateBlockVersionWithOutputResultError_notAuthorizedToUseMarkings | CanCreateBlockVersionWithOutputResultError_notAuthorizedToDeclassify;
interface CanCreateBlockVersionWithOutputResultOk {
}
interface CanCreateBlockVersionWithOutputsRequest {
    marketplaceRid: MarketplaceRid;
    resolvedOutputShapes: Record<BlockShapeId, ResolvedOutputShape>;
}
interface CanCreateBlockVersionWithOutputsResponse {
    results: Record<BlockShapeId, CanCreateBlockVersionWithOutputResult>;
}
/**
 * It is not permitted to change the backing datasource when upgrading an existing installation of an object/link type
 */
interface CannotChangeBackingDatasource {
    datasourceLocatorA: DatasourceLocator;
    datasourceLocatorB: DatasourceLocator;
}
interface CannotUpgradeToDifferentBlockId {
    existingBlockId: BlockId;
    newBlockId: BlockId;
    newBlockVersionId: BlockVersionId;
}
interface CarbonCreateBlockRequest {
    workspaceRid: string;
    workspaceVersion?: number | null | undefined;
}
interface CarbonWorkspaceIdentifier {
    rid: CarbonWorkspaceRid;
}
interface CarbonWorkspaceInputShape {
    about: LocalizedTitleAndDescription;
}
interface CarbonWorkspaceOutputShape {
    about: LocalizedTitleAndDescription;
}
type CarbonWorkspaceRid = string;
type CatalogTransactionRid = string;
interface Category {
    isImported: boolean;
    name: LocalizedName;
    rid: CategoryRid;
    tags: Array<Tag>;
}
type CategoryRid = string;
interface CbacMarkingConstraint {
    markingIds: Array<MarkingId>;
}
/**
 * Cbac marking constraints are not allowed on this stack. Cbac marking constraints are only allowed on stacks
 * that have Cbac enabled.
 */
interface CbacMarkingConstraintNotAllowed {
}
interface Changelog_markdown {
    type: "markdown";
    markdown: MarkdownText;
}
type Changelog = Changelog_markdown;
interface CheckCanExportFromStoreResponse {
    hasPermission: boolean;
    permissionDeniedReasons: Array<ExportPermissionDeniedReason>;
}
interface CheckCanUploadToStoreResponse {
    hasPermission: boolean;
}
interface CheckpointConfigCreateBlockRequest {
    rid: string;
}
interface CheckpointConfigEntityIdentifier {
    rid: CheckpointConfigRid;
}
interface CheckpointConfigOutputShape {
    about: LocalizedTitleAndDescription;
}
type CheckpointConfigRid = string;
interface ChildLevelAutomapping {
    parentShapeId: InputBlockSetShapeId;
}
interface CipherAlgorithm_aesGcmSiv {
    type: "aesGcmSiv";
    aesGcmSiv: Void;
}
interface CipherAlgorithm_aesSiv {
    type: "aesSiv";
    aesSiv: Void;
}
interface CipherAlgorithm_sha512 {
    type: "sha512";
    sha512: Void;
}
interface CipherAlgorithm_sha256 {
    type: "sha256";
    sha256: Void;
}
interface CipherAlgorithm_imageScrambling {
    type: "imageScrambling";
    imageScrambling: Void;
}
type CipherAlgorithm = CipherAlgorithm_aesGcmSiv | CipherAlgorithm_aesSiv | CipherAlgorithm_sha512 | CipherAlgorithm_sha256 | CipherAlgorithm_imageScrambling;
/**
 * The algorithm specified in the cipher channel is incompatible with the algorithms required by the shape.
 */
interface CipherChannelAlgorithmMismatch {
    actual: CipherAlgorithm;
    expectedOneOf: Array<CipherAlgorithm>;
}
interface CipherChannelCreateBlockRequest {
    channelRid: string;
    cryptographicKeyStrategy?: CryptographicKeyStrategy | null | undefined;
}
interface CipherChannelEntityIdentifier {
    rid: CipherChannelRid;
}
interface CipherChannelInputShape {
    about: LocalizedTitleAndDescription;
    allowedAlgorithms: Array<CipherAlgorithm>;
}
interface CipherChannelOutputShape {
    about: LocalizedTitleAndDescription;
    algorithm: CipherAlgorithm;
}
interface CipherChannelOutputSpecConfig {
    cryptographicKeyStrategy?: CryptographicKeyStrategy | null | undefined;
}
type CipherChannelRid = string;
/**
 * The algorithm specified in the license's cipher channel is incompatible with the algorithms required by the shape.
 */
interface CipherLicenseAlgorithmMismatch {
    actual: CipherAlgorithm;
    expectedOneOf: Array<CipherAlgorithm>;
}
interface CipherLicenseCreateBlockRequest {
    expirationStrategy?: ExpirationStrategy | null | undefined;
    licenseRid: string;
}
interface CipherLicenseEntityIdentifier {
    rid: CipherLicenseRid;
}
interface CipherLicenseInputIdentifier {
    requiredPermits: Array<CipherLicensePermit>;
    rid: CipherLicenseRid;
}
interface CipherLicenseInputShape {
    about: LocalizedTitleAndDescription;
    requiredPermits: Array<CipherLicensePermit>;
}
interface CipherLicenseInputShapeV2 {
    about: LocalizedTitleAndDescription;
    allowedAlgorithms: Array<CipherAlgorithm>;
    allowedLicenseTypes: Array<CipherLicenseType>;
    requiredOperations: Array<CipherOperationType>;
}
/**
 * The selected cipher license does not have all of the operations required by the shape.
 */
interface CipherLicenseMissingRequiredOperations {
    actualOperations: Array<CipherOperationType>;
    missingOperations: Array<CipherOperationType>;
    requiredOperations: Array<CipherOperationType>;
}
/**
 * The selected cipher license does not have all of the permits required by the shape.
 */
interface CipherLicenseMissingRequiredPermits {
    missingPermits: Array<CipherLicensePermit>;
}
interface CipherLicenseOutputShape {
    about: LocalizedTitleAndDescription;
    algorithm: CipherAlgorithm;
    licenseType: CipherLicenseType;
    operations: Array<CipherOperationType>;
}
interface CipherLicenseOutputSpecConfig {
    expirationStrategy?: ExpirationStrategy | null | undefined;
}
interface CipherLicensePermit_rateLimitedRequestPermit {
    type: "rateLimitedRequestPermit";
    rateLimitedRequestPermit: RateLimitedRequestPermit;
}
interface CipherLicensePermit_transformsRequestPermit {
    type: "transformsRequestPermit";
    transformsRequestPermit: TransformsRequestPermit;
}
interface CipherLicensePermit_highTrustRequestPermit {
    type: "highTrustRequestPermit";
    highTrustRequestPermit: HighTrustRequestPermit;
}
type CipherLicensePermit = CipherLicensePermit_rateLimitedRequestPermit | CipherLicensePermit_transformsRequestPermit | CipherLicensePermit_highTrustRequestPermit;
type CipherLicenseRid = string;
interface CipherLicenseType_operationalUserLicense {
    type: "operationalUserLicense";
    operationalUserLicense: Void;
}
interface CipherLicenseType_dataManagerLicense {
    type: "dataManagerLicense";
    dataManagerLicense: Void;
}
interface CipherLicenseType_adminLicense {
    type: "adminLicense";
    adminLicense: Void;
}
type CipherLicenseType = CipherLicenseType_operationalUserLicense | CipherLicenseType_dataManagerLicense | CipherLicenseType_adminLicense;
/**
 * The type of the license is incompatible with the types required by the shape.
 */
interface CipherLicenseTypeMismatch {
    actual: CipherLicenseType;
    expectedOneOf: Array<CipherLicenseType>;
}
interface CipherOperationType_encrypt {
    type: "encrypt";
    encrypt: Void;
}
interface CipherOperationType_decrypt {
    type: "decrypt";
    decrypt: Void;
}
interface CipherOperationType_hash {
    type: "hash";
    hash: Void;
}
type CipherOperationType = CipherOperationType_encrypt | CipherOperationType_decrypt | CipherOperationType_hash;
/**
 * Represents an encrypted property, generated by Cipher. It can essentially be treated as a string.
 */
interface CipherTextPropertyType {
    plainTextType: PrimitiveObjectPropertyType;
}
interface CleanupUnusedShapeError {
    error: ShapesRemovalError;
    unusedShapes: Array<UnusedShapeStatusEntry>;
}
/**
 * The cleanup unused shapes settings to use when installing a new installation or upgradiing an existing one.
 * Unused shapes are those that no longer belong to the target installation version. Specifically, given two
 * block set versions, old and new, unused shapes are the ones that are part of the old version but not the
 * new version. On upgrade, these shapes should be cleaned up (e.g., moved to trash or disabled); otherwise,
 * they will remain active and may produce unexpected side effects.
 */
interface CleanupUnusedShapesSettings {
    isEnabled: boolean;
}
/**
 * For more details about cleanup of unused shapes, please see CleanupUnusedShapesSettings docs.
 *
 * Each shape can only be in one status at a time and always progresses forward
 * (notStarted -> inProgress -> finished or failed).
 *
 * CleanupUnusedShapesStatuses does not fit well within ShapeInstallationStatuses because unused shapes are
 * never pre-allocated, reconciled, built, etc. The cleanup of unused shapes can be considered a side task
 * of the installation job; thus, it is better to keep its statuses separate from shape installation statuses.
 */
interface CleanupUnusedShapesStatuses {
    failed: Array<CleanupUnusedShapeError>;
    finished: Array<UnusedShapeStatusEntry>;
    inProgress: Array<UnusedShapeStatusEntry>;
    notStarted: Array<UnusedShapeStatusEntry>;
}
type CmafAudioCodec = "AAC" | "OPUS";
interface CmafStreamingFormat {
    audioCodec?: CmafAudioCodec | null | undefined;
    videoCodec: CmafVideoCodec;
}
type CmafVideoCodec = "H264" | "H265";
type CodeBlockSetParentRid = string;
interface CodeWorkspaceCreateBlockRequest {
    containerRid: string;
    containerVersionId?: string | null | undefined;
}
interface CodeWorkspaceIdentifier {
    containerRid: ContainerRid;
    containerVersionId?: ContainerVersionId | null | undefined;
}
/**
 * The image type of the code workspace does not match the expected type.
 */
interface CodeWorkspaceImageTypeMismatch {
    actual: ContainerImageType;
    expected: ContainerImageType;
}
interface CodeWorkspaceInputShape {
    about: LocalizedTitleAndDescription;
    imageType: ContainerImageType;
}
interface CodeWorkspaceLicenseIdentifier {
    licenseRid: string;
}
interface CodeWorkspaceLicenseInputShape {
    about: LocalizedTitleAndDescription;
    licenseProductType: LicenseProductType;
}
interface CodeWorkspaceOutputShape {
    about: LocalizedTitleAndDescription;
    imageType: ContainerImageType;
}
/**
 * The type of the column doesn't match the type required in the shape definition.
 */
interface ColumnTypeMismatch {
    actual: ConcreteDataType;
    expected: DatasourceColumnType;
}
interface CompassContext_project {
    type: "project";
    project: ProjectContext;
}
type CompassContext = CompassContext_project;
interface CompassCreateBlockRequest {
    folderRid: string;
}
type CompassFolderRid = string;
interface CompassFolderType {
}
/**
 * represents the intended purpose of the input.  An INSTALL_LOCATION will require INSTALL_IN permissions.
 * A REFERENCE would require USE_AS_INPUT permissions.
 */
type CompassFolderTypeConstraint = "INSTALL_LOCATION" | "REFERENCE";
interface CompassFolderTypeConstraints {
    constraints: Array<CompassFolderTypeConstraint>;
}
/**
 * The Compass location to install a block into.
 */
interface CompassInstallLocation {
    compassFolderRid: CompassFolderRid;
}
type CompassProjectRid = string;
interface CompassResourceInputIdentifier {
    allowedTypes: Array<CompassResourceType>;
    rid: string;
    typeConstraints: Array<CompassResourceTypeConstraints>;
}
interface CompassResourceInputShape {
    about: LocalizedTitleAndDescription;
    allowedTypes: Array<CompassResourceType>;
    typeConstraints: Array<CompassResourceTypeConstraints>;
}
/**
 * The type of this resource does not match one of the allowed types.
 */
interface CompassResourceInputShapeTypeMismatch {
    actual: ResourceType;
    expected: Array<ResourceType>;
}
interface CompassResourceOutputIdentifier {
    rid: string;
}
interface CompassResourceOutputShape {
    about: LocalizedTitleAndDescription;
    type: CompassResourceType;
}
/**
 * The type of this resource does not match one of the allowed types.
 */
interface CompassResourceOutputShapeTypeMismatch {
    actual: ResourceType;
    expected: ResourceType;
}
interface CompassResourceType_compassFolderType {
    type: "compassFolderType";
    compassFolderType: CompassFolderType;
}
type CompassResourceType = CompassResourceType_compassFolderType;
interface CompassResourceTypeConstraints_compassFolderTypeConstraints {
    type: "compassFolderTypeConstraints";
    compassFolderTypeConstraints: CompassFolderTypeConstraints;
}
type CompassResourceTypeConstraints = CompassResourceTypeConstraints_compassFolderTypeConstraints;
interface CompassSettings {
    newProjectOrExistingFolder: NewProjectOrExistingFolder;
}
type ComputeModuleIncludeFunctionsType = "INCLUDED_AS_OUTPUTS" | "EXCLUDED";
interface ComputeModuleOutputSpecConfig {
    includeFunctions?: ComputeModuleIncludeFunctionsType | null | undefined;
}
/**
 * A user-written application hosted in Compute Modules.
 */
interface ComputeModuleType {
}
interface ConcreteArrayType {
    elementType: ConcreteDataType;
}
interface ConcreteDataType_primitive {
    type: "primitive";
    primitive: ConcretePrimitiveDataType;
}
interface ConcreteDataType_array {
    type: "array";
    array: ConcreteArrayType;
}
interface ConcreteDataType_map {
    type: "map";
    map: ConcreteMapType;
}
interface ConcreteDataType_struct {
    type: "struct";
    struct: ConcreteStructType;
}
/**
 * Concrete types (still correspond 1:1 with types of columns of foundry datasets) but including higher
 * order types such as arrays, maps, structs.
 */
type ConcreteDataType = ConcreteDataType_primitive | ConcreteDataType_array | ConcreteDataType_map | ConcreteDataType_struct;
interface ConcreteDecimalType {
    precision: number;
    scale: number;
}
interface ConcreteMapType {
    keyType: ConcreteDataType;
    valueType: ConcreteDataType;
}
interface ConcretePrimitiveDataType_binary {
    type: "binary";
    binary: Void;
}
interface ConcretePrimitiveDataType_boolean {
    type: "boolean";
    boolean: Void;
}
interface ConcretePrimitiveDataType_byte {
    type: "byte";
    byte: Void;
}
interface ConcretePrimitiveDataType_date {
    type: "date";
    date: Void;
}
interface ConcretePrimitiveDataType_decimal {
    type: "decimal";
    decimal: ConcreteDecimalType;
}
interface ConcretePrimitiveDataType_double {
    type: "double";
    double: Void;
}
interface ConcretePrimitiveDataType_float {
    type: "float";
    float: Void;
}
interface ConcretePrimitiveDataType_integer {
    type: "integer";
    integer: Void;
}
interface ConcretePrimitiveDataType_long {
    type: "long";
    long: Void;
}
interface ConcretePrimitiveDataType_short {
    type: "short";
    short: Void;
}
interface ConcretePrimitiveDataType_string {
    type: "string";
    string: Void;
}
interface ConcretePrimitiveDataType_timestamp {
    type: "timestamp";
    timestamp: Void;
}
/**
 * These types are not composite (reference other types), or generic. They represent (nullable) primitive types.
 */
type ConcretePrimitiveDataType = ConcretePrimitiveDataType_binary | ConcretePrimitiveDataType_boolean | ConcretePrimitiveDataType_byte | ConcretePrimitiveDataType_date | ConcretePrimitiveDataType_decimal | ConcretePrimitiveDataType_double | ConcretePrimitiveDataType_float | ConcretePrimitiveDataType_integer | ConcretePrimitiveDataType_long | ConcretePrimitiveDataType_short | ConcretePrimitiveDataType_string | ConcretePrimitiveDataType_timestamp;
interface ConcreteStructElement {
    name: string;
    type: ConcreteDataType;
}
interface ConcreteStructType {
    fields: Array<ConcreteStructElement>;
}
type CondaExtension = "TAR_BZ2" | "CONDA";
/**
 * DEPRECATED - use CondaLocatorV2.
 * Reference a file in a conda files layout.
 */
interface CondaLocator {
    path: string;
}
/**
 * Reference a file in a conda files layout. It's a copy of com.palantir.artifacts.api.conda.CondaLocator.
 */
interface CondaLocatorV2 {
    buildString: string;
    extension: CondaExtension;
    name: string;
    platform: string;
    version: string;
}
/**
 * Untyped config object
 */
type ConfigBlock = Record<ConfigBlockKey, ConfigBlockValue>;
/**
 * Configuration key for untyped config objects
 */
type ConfigBlockKey = string;
/**
 * Configuration value for untyped config objects
 */
type ConfigBlockValue = any;
/**
 * A snapshot of a BlockSetInstallation where all block installations are in a single BlockSetVersion.
 */
interface ConsistentBlockSetInstallationState {
    blocks: Record<BlockSetBlockInstanceId, BlockInstallation>;
    blockSetVersionId: BlockSetVersionId;
    jobId: InstallBlocksJobId;
    jobRid: InstallBlocksJobRid;
}
interface ConstraintFailure_outsideMaintenanceWindows {
    type: "outsideMaintenanceWindows";
    outsideMaintenanceWindows: OutsideMaintenanceWindowsConstraintFailure;
}
interface ConstraintFailure_noNewerVersionsOnReleaseChannel {
    type: "noNewerVersionsOnReleaseChannel";
    noNewerVersionsOnReleaseChannel: NoNewerVersionsOnReleaseChannelConstraintFailure;
}
interface ConstraintFailure_lastUpgradeFailed {
    type: "lastUpgradeFailed";
    lastUpgradeFailed: LastUpgradeFailedConstraintFailure;
}
interface ConstraintFailure_missingInputs {
    type: "missingInputs";
    missingInputs: AllPossibleVersionsMissingInputsConstraintFailure;
}
interface ConstraintFailure_missingInputsV2 {
    type: "missingInputsV2";
    missingInputsV2: AllPossibleVersionsMissingInputsConstraintFailureV2;
}
interface ConstraintFailure_installationSpanningMultipleVersions {
    type: "installationSpanningMultipleVersions";
    installationSpanningMultipleVersions: Array<BlockSetVersionId>;
}
interface ConstraintFailure_inProgressJobForBlockSetInstallation {
    type: "inProgressJobForBlockSetInstallation";
    inProgressJobForBlockSetInstallation: InstallBlocksJobRid;
}
interface ConstraintFailure_automationDisabled {
    type: "automationDisabled";
    automationDisabled: Void;
}
interface ConstraintFailure_continuousInstallationHasBeenUpdatedRecently {
    type: "continuousInstallationHasBeenUpdatedRecently";
    continuousInstallationHasBeenUpdatedRecently: Void;
}
interface ConstraintFailure_unhandledValidationFailure {
    type: "unhandledValidationFailure";
    unhandledValidationFailure: UnhandledValidationFailure;
}
interface ConstraintFailure_unhandledValidationFailureV2 {
    type: "unhandledValidationFailureV2";
    unhandledValidationFailureV2: UnhandledValidationFailureV2;
}
interface ConstraintFailure_unhandledValidationFailureV3 {
    type: "unhandledValidationFailureV3";
    unhandledValidationFailureV3: UnhandledValidationFailureV3;
}
interface ConstraintFailure_noMaintenanceWindowsSet {
    type: "noMaintenanceWindowsSet";
    noMaintenanceWindowsSet: Void;
}
interface ConstraintFailure_isPartiallyDeletedInstallation {
    type: "isPartiallyDeletedInstallation";
    isPartiallyDeletedInstallation: Void;
}
interface ConstraintFailure_qosThrottle {
    type: "qosThrottle";
    qosThrottle: Void;
}
/**
 * Reason why upgrade automation will not run an upgrade. May require manual action to remidiate
 */
type ConstraintFailure = ConstraintFailure_outsideMaintenanceWindows | ConstraintFailure_noNewerVersionsOnReleaseChannel | ConstraintFailure_lastUpgradeFailed | ConstraintFailure_missingInputs | ConstraintFailure_missingInputsV2 | ConstraintFailure_installationSpanningMultipleVersions | ConstraintFailure_inProgressJobForBlockSetInstallation | ConstraintFailure_automationDisabled | ConstraintFailure_continuousInstallationHasBeenUpdatedRecently | ConstraintFailure_unhandledValidationFailure | ConstraintFailure_unhandledValidationFailureV2 | ConstraintFailure_unhandledValidationFailureV3 | ConstraintFailure_noMaintenanceWindowsSet | ConstraintFailure_isPartiallyDeletedInstallation | ConstraintFailure_qosThrottle;
type ConstraintFailures = Array<ConstraintFailure>;
/**
 * Represents the type of image used by the workspace.
 * A RSTUDIO workspace type will require a license to be provided.
 */
type ContainerImageType = "JUPYTER" | "RSTUDIO" | "DASH" | "STREAMLIT" | "RSHINY";
type ContainerRid = string;
type ContainerVersionId = string;
interface ContourAnalysisEntityIdentifier {
    rid: ContourAnalysisRid;
}
/**
 * Block-internal reference to a parent Contour analysis shape.
 */
type ContourAnalysisReference = BlockInternalId;
type ContourAnalysisRid = string;
interface ContourAnalysisShape {
    about: LocalizedTitleAndDescription;
    refs: Array<ContourRefReference>;
}
interface ContourCreateBlockRequest {
    analysisRid: string;
}
/**
 * Determines which integration service handles contour resources during packaging and installation.
 * This field is during the migration phase from legacy Templates to new Contour Dispatch implementation.
 */
type ContourIntegrationSource = "TEMPLATES" | "CONTOUR_DISPATCH";
interface ContourOutputSpecConfig {
    integrationSource?: ContourIntegrationSource | null | undefined;
}
interface ContourRefEntityIdentifier {
    analysisRid: ContourAnalysisRid;
    rid: ContourRefRid;
}
/**
 * Block-internal reference to a child Contour ref shape.
 */
type ContourRefReference = BlockInternalId;
type ContourRefRid = string;
/**
 * Represents a path (ref) within a Contour analysis. This is a child shape
 * of ContourAnalysisShape, used to track RefRid mappings across stacks.
 */
interface ContourRefShape {
    about: LocalizedTitleAndDescription;
    analysis: ContourAnalysisReference;
}
interface ContractExpressionIdentifier_and {
    type: "and";
    and: AndExpressionIdentifier;
}
interface ContractExpressionIdentifier_or {
    type: "or";
    or: OrExpressionIdentifier;
}
interface ContractExpressionIdentifier_contract {
    type: "contract";
    contract: FunctionContractIdentifier;
}
/**
 * A boolean expression tree for specifying contract requirements. Parallel to ContractExpression,
 * but uses FunctionContractIdentifier for leaf nodes instead of FunctionContractReference (BlockInternalId).
 */
type ContractExpressionIdentifier = ContractExpressionIdentifier_and | ContractExpressionIdentifier_or | ContractExpressionIdentifier_contract;
interface CreateBlockSetFromStartingVersionRequest {
    overriddenMetadata?: OverriddenMetadataFromStartingVersion | null | undefined;
    overriddenSpecs?: OverriddenOutputSpecs | null | undefined;
    shouldRefresh: boolean;
    startingVersion: BlockSetVersionId;
}
interface CreateBlockSetVersionRequest {
    draftGroupRid?: DraftGroupRid | null | undefined;
    isHotfix?: boolean | null | undefined;
    isListable?: boolean | null | undefined;
    startingVersion?: CreateBlockSetFromStartingVersionRequest | null | undefined;
}
interface CreateBlockSetVersionResponse {
    blockSetId: BlockSetId;
    blockSetVersionId: BlockSetVersionId;
}
interface CreateBlockVersionError {
    error: CreateBlockVersionErrorUnion;
    severity: ErrorSeverity;
}
interface CreateBlockVersionErrorUnion_serializable {
    type: "serializable";
    serializable: SerializableCreateBlockVersionError;
}
interface CreateBlockVersionErrorUnion_genericV2 {
    type: "genericV2";
    genericV2: GenericCreateBlockVersionErrorV2;
}
interface CreateBlockVersionErrorUnion_generic {
    type: "generic";
    generic: GenericCreateBlockVersionError;
}
type CreateBlockVersionErrorUnion = CreateBlockVersionErrorUnion_serializable | CreateBlockVersionErrorUnion_genericV2 | CreateBlockVersionErrorUnion_generic;
/**
 * Create a new version of a block by specifying everything needed directly.
 * The kind of the block is defined via the block configuration.
 * The block version will not be successfully created until all block data has been supplied.
 */
interface CreateBlockVersionRequest {
    about: LocalizedTitleAndDescription;
    blockDataToBeSupplied: Record<BlockDataId, SerializedDataLocator>;
    blockSetVersionId?: BlockSetVersionId | null | undefined;
    configuration: BlockSpecificConfiguration;
    inputGroups: Record<InputGroupId, InputGroup>;
    inputMetadata: Record<BlockShapeId, InputShapeMetadata>;
    inputs: Record<BlockShapeId, InputShape>;
    knownIdentifiers: Record<KnownIdentifier, BlockInternalId>;
    lastVersionId?: BlockVersionId | null | undefined;
    outputs: Record<BlockShapeId, OutputShape>;
    packagingRequest?: BlockSpecificCreateRequest | null | undefined;
    resolvedInputs: Record<BlockShapeId, ResolvedInputShape>;
    resolvedOutputs: Record<BlockShapeId, ResolvedOutputShape>;
}
interface CreateBlockVersionResponse {
    blockDataArtifactsRepositoryRid: ArtifactsRepositoryRid;
    blockId: BlockId;
    blockVersionId: BlockVersionId;
}
interface CreateDraftGroupRequest {
    marketplaceRid: MarketplaceRid;
    versionIds: Array<BlockSetVersionId>;
}
/**
 * Request to create a new installation job draft.
 */
interface CreateJobDraftRequest {
    installations: Array<TargetInstallationSpec>;
}
interface CreateJobDraftResponse {
    draft: UnresolvedJobDraft;
    metadata: JobDraftMetadata;
}
interface CreateMarketplaceRequest {
    definition: MarketplaceDefinition;
    markings: Array<MarkingId>;
    name: string;
    parentRid: string;
}
interface CreateNewBlockSetInstallation {
    targetLocation: TargetInstallLocationV2;
    targetState: BlockSetInstallationTargetState;
}
interface CreatePlaceholdersRequest {
    inputShapesToCreatePlaceholdersFor: Record<InputBlockSetShapeId, BlockSetInputShape>;
    location: PlaceholdersLocation;
    markingIds: Array<MarkingId>;
}
interface CreatePlaceholdersResponse {
    resolvedInputShapes: Record<InputBlockSetShapeId, ResolvedBlockSetInputShape>;
}
/**
 * Request to create a new product group.
 */
interface CreateProductGroupRequest {
    about: LocalizedTitleAndDescription;
    initialMembers: Array<ProductGroupMemberSpec>;
    parentRid: CompassFolderRid;
    validationSettings?: ProductGroupValidationSettings | null | undefined;
}
interface CreateProductGroupResponse {
    productGroup: ProductGroup;
}
interface CreateProjectRequest {
    cbacMarkingConstraint?: CbacMarkingConstraint | null | undefined;
    namespaceRid: NamespaceRid;
    organizationMarkingIds?: Array<MarkingId> | null | undefined;
    projectName: string;
    roleContext: InstallationProjectRoleContext;
    roleGrants: Array<RoleGrant>;
}
/**
 * Request to create a snapshot manually.
 */
interface CreateSnapshotRequest {
    description?: LocalizedDescription | null | undefined;
}
/**
 * Response containing the newly created manual snapshot.
 */
interface CreateSnapshotResponse {
    productGroupRid: ProductGroupRid;
    snapshotRid: ProductGroupSnapshotRid;
}
type CreationTimestamp = string;
interface CredentialHasIncorrectSecretNames {
    actual: Array<SecretName>;
    expected: Array<SecretName>;
}
/**
 * The equivalent of `CredentialId` in Magritte's `NamedCredentialService`.
 */
type CredentialRid = string;
type CronExpression = string;
/**
 * Cron expression localized in a specific timezone.
 */
interface CronWithTimeZoneValue {
    cronExpression: CronExpression;
    zoneId: ZoneId;
}
interface CrossStackConfigSigningPublicKeyEntry {
    publicKey: SigningPublicKey;
    publicKeyId: SigningKeyId;
}
/**
 * Conjure representation of a yaml file located in:
 * https://github.palantir.build/foundry/marketplace-cross-stack-config/blob/develop/marketplace-cross-stack-config/marketplace-config/public-keys.yml
 */
interface CrossStackConfigSigningPublicKeys {
    entries: Record<string, Array<CrossStackConfigSigningPublicKeyEntry>>;
}
interface CryptographicKeyStrategy_keepSameKey {
    type: "keepSameKey";
    keepSameKey: Void;
}
interface CryptographicKeyStrategy_autoGenerateNewKey {
    type: "autoGenerateNewKey";
    autoGenerateNewKey: Void;
}
type CryptographicKeyStrategy = CryptographicKeyStrategy_keepSameKey | CryptographicKeyStrategy_autoGenerateNewKey;
/**
 * A single directed dependency edge between two members of a strongly-connected component,
 * showing which outputs of the upstream member fulfill which inputs of the downstream member.
 * Edges are aggregated from two sources: shape-merge-key matches (an output's merge key matches
 * an input's merge key) and external recommendations (a downstream member declares its input is
 * fulfilled by a specific upstream output). Both contribute pairs to `fulfillments`.
 */
interface CycleDependencyEdge {
    downstream: ProductGroupMemberRid;
    fulfillments: Record<InputBlockSetShapeId, OutputBlockSetShapeId>;
    upstream: ProductGroupMemberRid;
}
interface DataCommitBlockVersionFailedRequest {
    error?: MarketplaceSerializableError | null | undefined;
    errorInstanceId?: ErrorInstanceId | null | undefined;
    errorMessage: string;
}
/**
 * Data constraints on a property (or interface property) describing what values the property accepts.
 * Mirrors the OMS `DataConstraints` type.
 */
interface DataConstraints {
    nullabilityV2?: DataNullabilityV2 | null | undefined;
}
interface DataHealthCheckCreateBlockRequest {
    checkRid: string;
}
interface DataHealthCheckGroupIdentifier {
    rid: DataHealthCheckGroupRid;
}
type DataHealthCheckGroupRid = string;
interface DataHealthCheckGroupShape {
    about: LocalizedTitleAndDescription;
}
interface DataHealthCheckIdentifier {
    rid: DataHealthCheckRid;
}
type DataHealthCheckRid = string;
interface DataHealthCheckShape {
    about: LocalizedTitleAndDescription;
}
/**
 * Mirrors the OMS `DataNullabilityV2` type. Each field is optional for backwards compatibility.
 */
interface DataNullabilityV2 {
    noEmptyCollections?: boolean | null | undefined;
    noNulls?: boolean | null | undefined;
}
interface DatasetLocator {
    branch: string;
    rid: string;
}
interface DatasetLocatorIdentifier {
    branch?: string | null | undefined;
    rid: string;
}
/**
 * Configures whether to package the dataset with its data statically, or include the producer that puts the
 * job spec for the dataset. Exactly one of `includeProducer` and `includeData` must be true.
 */
interface DatasetOutputSpecConfig {
    includeData: boolean;
    includeProducer: boolean;
}
/**
 * The tabular datasource referenced already backs an existing link type in the ontology.
 * Reusing a backing datasource across link types is not permitted.
 */
interface DatasourceAlreadyBacksExistingLinkType {
    datasourceLocator: DatasourceLocator;
    linkTypeRid: LinkTypeRid;
}
/**
 * The tabular datasource referenced already backs an existing object type in the ontology.
 * Reusing a backing datasource across object types is not permitted.
 */
interface DatasourceAlreadyBacksExistingObjectType {
    datasourceLocator: DatasourceLocator;
    objectTypeRid: ObjectTypeRid;
}
/**
 * The RID of a resource that backs a datasource in OMS, e.g. a dataset RID or an restricted view RID.
 *
 * Different from `DatasourceRid`, which is an internal RID that OMS uses to identify its datasources.
 */
type DatasourceBackingRid = string;
interface DatasourceBuildRequirements {
    isBuildable: boolean;
}
interface DatasourceColumnIdentifier_nameBased {
    type: "nameBased";
    nameBased: NameBasedDatasourceColumnIdentifier;
}
type DatasourceColumnIdentifier = DatasourceColumnIdentifier_nameBased;
type DatasourceColumnReference = BlockInternalId;
interface DatasourceColumnShape {
    about: LocalizedTitleAndDescription;
    datasource: TabularDatasourceReference;
    type: DatasourceColumnType;
    typeclasses: Array<DatasourceColumnTypeClass>;
}
interface DatasourceColumnType_concrete {
    type: "concrete";
    concrete: ConcreteDataType;
}
interface DatasourceColumnType_generic {
    type: "generic";
    generic: GenericDataType;
}
type DatasourceColumnType = DatasourceColumnType_concrete | DatasourceColumnType_generic;
interface DatasourceColumnTypeClass_eddieDefined {
    type: "eddieDefined";
    eddieDefined: EddieDefinedTypeClass;
}
interface DatasourceColumnTypeClass_valueType {
    type: "valueType";
    valueType: ValueTypeReference;
}
type DatasourceColumnTypeClass = DatasourceColumnTypeClass_eddieDefined | DatasourceColumnTypeClass_valueType;
interface DatasourceLocator_stream {
    type: "stream";
    stream: StreamLocator;
}
interface DatasourceLocator_dataset {
    type: "dataset";
    dataset: DatasetLocator;
}
interface DatasourceLocator_restrictedView {
    type: "restrictedView";
    restrictedView: RestrictedViewLocator;
}
interface DatasourceLocator_virtualTable {
    type: "virtualTable";
    virtualTable: VirtualTableLocator;
}
interface DatasourceLocator_directSource {
    type: "directSource";
    directSource: DirectSourceLocator;
}
type DatasourceLocator = DatasourceLocator_stream | DatasourceLocator_dataset | DatasourceLocator_restrictedView | DatasourceLocator_virtualTable | DatasourceLocator_directSource;
interface DatasourceLocatorIdentifier_stream {
    type: "stream";
    stream: StreamLocatorIdentifier;
}
interface DatasourceLocatorIdentifier_dataset {
    type: "dataset";
    dataset: DatasetLocatorIdentifier;
}
interface DatasourceLocatorIdentifier_restrictedView {
    type: "restrictedView";
    restrictedView: RestrictedViewLocatorIdentifier;
}
interface DatasourceLocatorIdentifier_virtualTable {
    type: "virtualTable";
    virtualTable: VirtualTableLocatorIdentifier;
}
interface DatasourceLocatorIdentifier_directSource {
    type: "directSource";
    directSource: DirectSourceLocatorIdentifier;
}
type DatasourceLocatorIdentifier = DatasourceLocatorIdentifier_stream | DatasourceLocatorIdentifier_dataset | DatasourceLocatorIdentifier_restrictedView | DatasourceLocatorIdentifier_virtualTable | DatasourceLocatorIdentifier_directSource;
/**
 * An unknown type of `DatasourceLocator` definition was encountered. This indicates we might have run into a new
 * kind of `DatasourceLocator` that isn't yet supported in Marketplace.
 */
interface DatasourceLocatorTypeUnknown {
    unknownType: string;
}
type DatasourceReference = BlockInternalId;
interface DataType_stringType {
    type: "stringType";
    stringType: Void;
}
interface DataType_booleanType {
    type: "booleanType";
    booleanType: Void;
}
interface DataType_integerType {
    type: "integerType";
    integerType: Void;
}
interface DataType_cronWithTimeZoneType {
    type: "cronWithTimeZoneType";
    cronWithTimeZoneType: Void;
}
type DataType = DataType_stringType | DataType_booleanType | DataType_integerType | DataType_cronWithTimeZoneType;
interface DataValue_booleanValue {
    type: "booleanValue";
    booleanValue: BooleanValue;
}
interface DataValue_stringValue {
    type: "stringValue";
    stringValue: StringValue;
}
interface DataValue_integerValue {
    type: "integerValue";
    integerValue: IntegerValue;
}
interface DataValue_cronWithTimeZoneValue {
    type: "cronWithTimeZoneValue";
    cronWithTimeZoneValue: CronWithTimeZoneValue;
}
type DataValue = DataValue_booleanValue | DataValue_stringValue | DataValue_integerValue | DataValue_cronWithTimeZoneValue;
/**
 * DateListType specifies that this parameter must be a list of Dates.
 */
interface DateListType {
}
/**
 * DateType specifies that this parameter must be a Date.
 */
interface DateType {
}
type DayOfWeek = "SUNDAY" | "MONDAY" | "TUESDAY" | "WEDNESDAY" | "THURSDAY" | "FRIDAY" | "SATURDAY";
interface DayTime {
    day: DayOfWeek;
    time: LocalTime;
}
/**
 * DecimalListType specifies that this parameter must be a list of Decimals.
 */
interface DecimalListType {
    precision?: number | null | undefined;
    scale?: number | null | undefined;
}
/**
 * DecimalType specifies that this parameter must be a Decimal.
 */
interface DecimalType {
    precision?: number | null | undefined;
    scale?: number | null | undefined;
}
/**
 * This configuration indicates that on functions block installation...
 * (1) The function version that is pre-allocated is determined by incrementing the minor version of the existing
 * function's latest version (for initial installs, "0.1.0" is used).
 *
 * For example, if the existing function has latest version "1.2.3", pre-allocation will return version "1.3.0".
 *
 * (2) The API name that is pre-allocated is deduplicated if a conflict exists, which currently entails adding an
 * incrementing integer suffix.
 *
 * For example, if the function has API name "myFunction", pre-allocation will use "myFunction1" if a
 * conflict exists in the target location.
 *
 * This configuration is encouraged in production mode installations, but exists for backward compatibility with
 * old behavior.
 */
interface DeduplicateFunctionsApiStabilityConfiguration {
}
interface DefaultBlockSpecificConfiguration_v0 {
    type: "v0";
    v0: ManifestOnlyBlockSpecificConfigurationV0;
}
type DefaultBlockSpecificConfiguration = DefaultBlockSpecificConfiguration_v0;
/**
 * Settings defined by the user at packaging time that are tied to this particular version of the block set.
 * If these are not overridden at installation time, these will be used as the installation settings.
 * If not included, we will fall back to Marketplace default settings.
 */
interface DefaultInstallationSettings {
    buildSettings: BuildSettings;
    cleanupUnusedShapesSettings?: CleanupUnusedShapesSettings | null | undefined;
    createOntologyPackage?: boolean | null | undefined;
    ontologyProjectAssociation?: OntologyProjectAssociation | null | undefined;
}
/**
 * The shape does not have a default value for the preset, even though user has requested resolution
 * using a default.
 */
interface DefaultRequestedForShapeWithNoDefault {
}
/**
 * Resolving the default for the shape failed.
 */
interface DefaultResolutionFailedError {
    resolutionError: ResolvedShapeResolutionFailure;
}
interface DeleteBlockSetInstallationAllowance_allowed {
    type: "allowed";
    allowed: Void;
}
interface DeleteBlockSetInstallationAllowance_disallowed {
    type: "disallowed";
    disallowed: DeleteBlockSetInstallationDisallowed;
}
type DeleteBlockSetInstallationAllowance = DeleteBlockSetInstallationAllowance_allowed | DeleteBlockSetInstallationAllowance_disallowed;
interface DeleteBlockSetInstallationDisallowed {
    rationale: DeleteBlockSetInstallationPermissionDeniedRationale;
}
interface DeleteBlockSetInstallationPermissionDeniedRationale {
    blockSetInstallationRid: BlockSetInstallationRid;
}
interface DeleteDraftGroupResponse {
}
interface DeleteJobDraftResponse {
}
/**
 * Includes a registered public key that will be deleted and no longer be able to verify any maven coordinates
 */
interface DeleteKeyRequest {
    publicKey: SigningPublicKey;
}
interface DeleteKeyResponse {
}
interface DependencyProvenance {
    parent: ResolvedOutputSpec;
}
interface DeployedAppCreateBlockRequest {
    deployedAppRid: string;
    includeFunctions?: ComputeModuleIncludeFunctionsType | null | undefined;
}
interface DeployedAppIdentifier {
    rid: DeployedAppRid;
}
type DeployedAppRid = string;
interface DeployedAppShape {
    about: LocalizedTitleAndDescription;
}
type DeprecationStatus = "DEPRECATED" | "NOT_DEPRECATED";
/**
 * We current only provide support for overriding the fallback description, not the localized mappings.
 */
interface DescriptionOverride {
    fallbackDescription: string;
}
interface DescriptionOverrideRequest_set {
    type: "set";
    set: DescriptionOverride;
}
interface DescriptionOverrideRequest_remove {
    type: "remove";
    remove: Void;
}
type DescriptionOverrideRequest = DescriptionOverrideRequest_set | DescriptionOverrideRequest_remove;
type DiagramRid = string;
interface DicomSchema {
}
/**
 * The granularity at which to return a diff.
 *
 * FULL: Returns the full diff, including all shapes.
 * MINIFIED: Returns a minified diff, which does not include child shapes or Compass install location inputs.
 */
type DiffGranularity = "FULL" | "MINIFIED";
interface DirectDatasourceCreateBlockRequest {
    directSourceRid: string;
    ontologyVersion?: string | null | undefined;
}
interface DirectSourceLocator {
    rid: string;
}
interface DirectSourceLocatorIdentifier {
    rid: string;
}
/**
 * By default, all folder resources are discovered using a simple Compass traversal.
 * If any field below is specified, it will be used to additionally discover non-Compass resources of that type.
 * If a field is omitted or empty, resources of that type will not be discovered.
 */
interface DiscoveryConfig {
    functions?: IncludeFunctionsConfig | null | undefined;
    healthChecks?: IncludeHealthCheckConfig | null | undefined;
    objectViews?: IncludeObjectViewsConfig | null | undefined;
    ontologyEntities?: IncludeOntologyEntitiesConfig | null | undefined;
    schedules?: IncludeSchedulesConfig | null | undefined;
}
interface DiscoveryProvenance {
    parent: DiscoverySpec;
}
/**
 * Applies to `discoverySpecs` in the update. If no `discoverySpecs` are provided, these settings will have no
 * effect.
 */
interface DiscoverySettings {
    discoveryConfig?: DiscoveryConfig | null | undefined;
    ignoreConfig?: IgnoreConfig | null | undefined;
}
/**
 * A resource that we use as a seed for the discovery of OutputSpec resources to package. For example, a Compass
 * project from which we discover OutputSpecs based on the resources in the project.
 */
interface DiscoverySpec {
    rid: string;
}
interface DocFormat {
}
interface DocumentationManifestV1 {
    attachmentList: Array<AttachmentMetadata>;
    freeFormSections?: FreeFormDocumentationSections | null | undefined;
    links?: Links | null | undefined;
    localizedFreeFormSections?: LocalizedFreeFormDocumentationSections | null | undefined;
    thumbnail?: AttachmentMetadata | null | undefined;
}
interface DocumentDecodeFormat_pdf {
    type: "pdf";
    pdf: PdfFormat;
}
interface DocumentDecodeFormat_doc {
    type: "doc";
    doc: DocFormat;
}
interface DocumentDecodeFormat_docx {
    type: "docx";
    docx: DocxFormat;
}
interface DocumentDecodeFormat_rtf {
    type: "rtf";
    rtf: RtfFormat;
}
interface DocumentDecodeFormat_txt {
    type: "txt";
    txt: TxtFormat;
}
interface DocumentDecodeFormat_pptx {
    type: "pptx";
    pptx: PptxFormat;
}
type DocumentDecodeFormat = DocumentDecodeFormat_pdf | DocumentDecodeFormat_doc | DocumentDecodeFormat_docx | DocumentDecodeFormat_rtf | DocumentDecodeFormat_txt | DocumentDecodeFormat_pptx;
interface DocumentSchema {
    format: DocumentDecodeFormat;
}
interface DocxFormat {
}
/**
 * DoubleListType specifies that this parameter must be a list of Doubles.
 */
interface DoubleListType {
}
/**
 * DoubleType specifies that this parameter must be a Double.
 */
interface DoubleType {
}
interface DraftGroup {
    createdAt: CreationTimestamp;
    createdBy: MultipassUserId;
    lastUpdatedAt: LastUpdatedTimestamp;
    marketplaceRid: MarketplaceRid;
    rid: DraftGroupRid;
    versionIds: Array<BlockSetVersionId>;
}
interface DraftGroupErrorStatus {
}
interface DraftGroupFinalizedStatus {
    finalized: Array<BlockSetVersionId>;
}
interface DraftGroupFinalizingStatus {
    finalized: Array<BlockSetVersionId>;
    finalizing: Array<BlockSetVersionId>;
    isCancelled: boolean;
    notAttempted: Array<BlockSetVersionId>;
}
interface DraftGroupGeneratingRecommendationsStatus {
}
/**
 * UUID identifier for a draft group, used as the FSM instance ID.
 */
type DraftGroupId = string;
interface DraftGroupIdleStatus {
}
interface DraftGroupProcessingStatus {
}
/**
 * Unique identifier for a draft group of pending block set versions.
 */
type DraftGroupRid = string;
interface DraftGroupStatus_idle {
    type: "idle";
    idle: DraftGroupIdleStatus;
}
interface DraftGroupStatus_processing {
    type: "processing";
    processing: DraftGroupProcessingStatus;
}
interface DraftGroupStatus_generatingRecommendations {
    type: "generatingRecommendations";
    generatingRecommendations: DraftGroupGeneratingRecommendationsStatus;
}
interface DraftGroupStatus_error {
    type: "error";
    error: DraftGroupErrorStatus;
}
interface DraftGroupStatus_finalizing {
    type: "finalizing";
    finalizing: DraftGroupFinalizingStatus;
}
interface DraftGroupStatus_finalized {
    type: "finalized";
    finalized: DraftGroupFinalizedStatus;
}
type DraftGroupStatus = DraftGroupStatus_idle | DraftGroupStatus_processing | DraftGroupStatus_generatingRecommendations | DraftGroupStatus_error | DraftGroupStatus_finalizing | DraftGroupStatus_finalized;
/**
 * The `AssociatedBlockSetInstallation` is referencing the same block with multiple `BlockSetBlockInstanceId`(s).
 *
 * Each `BlockSetBlockInstanceId` should be mapped to a unique block.
 */
interface DuplicateBlockReference {
    blockReference: BlockReference;
    instanceIds: Array<BlockSetBlockInstanceId>;
}
interface DuplicateBlockSetVersionsInRequest {
    duplicatedBlockSetVersionIds: Array<InstallableBlockSetVersionId>;
}
/**
 * A tabular datasource has duplicate resolved columns
 */
interface DuplicateColumns {
    columnReferences: Array<DatasourceColumnReference>;
    tabularDatasourceReference: TabularDatasourceReference;
}
/**
 * Two or more top-level outputs across the product group's members resolve to the same underlying resource. One
 * finding is emitted per duplicated merge key; the merge key itself is not included in the payload — clients
 * infer the relationship from the listed outputs. When downstream members have conflicting recommendations
 * due to the duplicated outputs, the finding severity is escalated to `ERROR`; otherwise `WARN`.
 */
interface DuplicateOutputs {
    downstreamOverlappingRecommendations: Record<ProductGroupMemberRid, InputBlockSetShapeId>;
    outputsByMember: Record<ProductGroupMemberRid, Array<OutputBlockSetShapeId>>;
}
/**
 * Other tabular datasource shapes resolve to this tabular datasource.
 * There should only be one instance of a resolved tabular datasource.
 */
interface DuplicateTabularDatasources {
    tabularDatasourceReferences: Array<TabularDatasourceReference>;
}
/**
 * The pipeline will ignore state breaks and continue reading data if possible
 */
interface EddieAcknowledgeStateBreakOption {
}
/**
 * Creates an eddie block based on the latest version that backs the main branch.
 */
interface EddieCreateBlockRequest {
    pipelineRid: string;
    targetEnvironments: Array<TargetEnvironment>;
}
/**
 * Describes the built-in eddie logical type from the logical types in the Eddie registry. Must be an exact
 * match with all the defined fields. The metadata field is ignored for now.
 */
interface EddieDefinedTypeClass {
    kind: string;
    name: string;
    version?: EddieDefinedTypeClassVersion | null | undefined;
}
/**
 * Describes the version of a column typeclass.
 */
interface EddieDefinedTypeClassVersion {
    major: number;
    minor?: number | null | undefined;
    patch?: number | null | undefined;
}
interface EddieEdgeParameterInputIdentifier {
    instantiation: ResolvedEddieParameter;
    parameterId: ParameterId;
    rid: EddiePipelineRid;
    type: EddieInputParameterType;
    versionId: EddieVersionId;
}
/**
 * There are a number of valid parameter types in Eddie, from simple parameters like literals to more complex
 * parameters like list<expression>.
 * The shape parameter type describes which parameter must be passed when resolving this shape.
 */
interface EddieEdgeParameterInputShape {
    about: LocalizedTitleAndDescription;
    type: EddieInputParameterType;
}
/**
 * A identifier used when merging resolved shapes to determine if a breaking change has occurred and the resolved
 * shape needs to be redefined. See https://palantir.quip.com/CPnMAn3dndba for design decisions.
 */
interface EddieEdgeParameterShapeMergeKey {
    stableId?: EddieEdgeStableParameterId | null | undefined;
}
/**
 * Creates an edge pipeline block from a provided eddie pipeline rid. Edge Pipelines are always derived from
 * Eddie Pipelines.
 */
interface EddieEdgePipelineCreateBlockRequest {
    eddiePipelineRid: string;
}
interface EddieEdgePipelineIdentifier {
    rid: EddieEdgePipelineRid;
}
/**
 * The RID of a dataset input to a pipeline.
 */
type EddieEdgePipelineInputDatasetRid = string;
/**
 * Never consumed by any downstream blocks but indicates that a block creates an Eddie pipeline.
 */
interface EddieEdgePipelineOutputShape {
    about?: LocalizedTitleAndDescription | null | undefined;
}
/**
 * The RID of the eddie pipeline.
 */
type EddieEdgePipelineRid = string;
interface EddieEdgeStableParameterId {
    parameterId: ParameterId;
    pipelineRid: EddiePipelineRid;
}
/**
 * This will allow users to configure destination and spec options for a Geotime Target in Pipeline Builder.
 */
interface EddieGeotimeConfigurationInputShape {
    about: LocalizedTitleAndDescription;
    id?: StableShapeIdentifier | null | undefined;
}
/**
 * The Namespace and Destination stack that a Geotime Target is writing to.
 */
interface EddieGeotimeDestination {
    destinationId: string;
    namespaceRid?: NamespaceRid | null | undefined;
}
interface EddieGeotimeInputIdentifier {
    geotimeTargetId: EddieGeotimeTargetId;
    rid: EddiePipelineRid;
}
/**
 * ID of a Geotime Target in the packaged pipeline.
 */
type EddieGeotimeTargetId = string;
interface EddieInputParameterType_primitive {
    type: "primitive";
    primitive: EddiePrimitiveParameterType;
}
/**
 * A list of renderable parameter types that marketplace <-> eddie supports.
 */
type EddieInputParameterType = EddieInputParameterType_primitive;
/**
 * Parameter that represents literal value of a given type.
 * Instance type: LiteralParameter
 */
interface EddieLiteralParameterType {
    additionalConstraints: Array<LiteralConstraint>;
    requiredType: EddieTypeReference;
}
/**
 * DEPRECATED - Prefer EddieParameterShapeV2 as it contains only supported in the UI parameter types.
 *
 * Specifies an input parameter to an Eddie group.
 * There are a number of valid parameter types in Eddie, from simple parameters like literals to more complex
 * parameters like list<expression>.
 * The shape parameter type describes which parameter must be passed when resolving this shape.
 */
interface EddieParameterShape {
    about: LocalizedTitleAndDescription;
    isOptional: boolean;
    type: InputParameterType;
}
/**
 * There are a number of valid parameter types in Eddie, from simple parameters like literals to more complex
 * parameters like list<expression>.
 * The shape parameter type describes which parameter must be passed when resolving this shape.
 */
interface EddieParameterShapeV2 {
    about: LocalizedTitleAndDescription;
    id?: StableShapeIdentifier | null | undefined;
    type: EddieInputParameterType;
}
/**
 * The Namespace and Destination stack that a Geotime Integration will be peered to.
 */
interface EddiePeeredGeotimeDestination {
    destinationId: string;
    namespaceRid: NamespaceRid;
}
interface EddiePipelineIdentifier {
    rid: EddiePipelineRid;
}
interface EddiePipelineOutputSpecConfig {
    targetEnvironment?: TargetEnvironment | null | undefined;
}
type EddiePipelineRid = string;
/**
 * Never consumed by any downstream blocks but indicates that a block creates an Eddie pipeline.
 */
interface EddiePipelineShape {
    about?: LocalizedTitleAndDescription | null | undefined;
}
/**
 * An Eddie Pipeline that may contain various UDFs.
 */
interface EddiePipelineType {
}
interface EddiePrimitiveParameterType_literal {
    type: "literal";
    literal: EddieLiteralParameterType;
}
interface EddiePrimitiveParameterType_regex {
    type: "regex";
    regex: RegexParameterType;
}
/**
 * This is a subset union of EddieInputParameterType
 */
type EddiePrimitiveParameterType = EddiePrimitiveParameterType_literal | EddiePrimitiveParameterType_regex;
/**
 * Both remote and peered destinations cannot be configured for a geotime target.
 */
interface EddieRemoteAndPeeredDestinationsConflictError {
    peeredDestinations: Array<EddiePeeredGeotimeDestination>;
    remoteDestinations: Array<EddieGeotimeDestination>;
}
interface EddieReplayOptionShape {
    about: LocalizedTitleAndDescription;
    id?: StableShapeIdentifier | null | undefined;
    supportedReplayOptions: Array<EddieReplayOptionType>;
}
type EddieReplayOptionType = "RESET_AND_REPLAY_FROM_OFFSET" | "RESET" | "ACKNOWLEDGE_STATE_BREAKS";
/**
 * The pipeline will be reset with the data received before the given offset time.
 */
interface EddieResetAndReplayFromOffsetOption {
    offsetMillis: number;
}
/**
 * The pipeline will be reset with all the data
 */
interface EddieResetOption {
}
interface EddieTypeReference_explicit {
    type: "explicit";
    explicit: ExplicitType;
}
type EddieTypeReference = EddieTypeReference_explicit;
type EddieVersionId = string;
/**
 * Configuration key for untyped Magritte config objects
 */
type EdgeMagritteConfigKey = string;
/**
 * Configuration value for untyped Magritte config objects
 */
type EdgeMagritteConfigValue = any;
/**
 * Port configuration for edge magritte source
 */
interface EdgeMagrittePortConfig {
    tcpPorts: Array<PortConfig>;
    udpPorts: Array<PortConfig>;
}
/**
 * Untyped Magritte source config object
 */
type EdgeMagritteSourceConfig = Record<EdgeMagritteConfigKey, EdgeMagritteConfigValue>;
/**
 * Untyped Magritte task config object
 */
type EdgeMagritteTaskConfig = Record<EdgeMagritteConfigKey, EdgeMagritteConfigValue>;
/**
 * Magritte task type (also used to represent sync types)
 */
type EdgeMagritteTaskType = string;
interface EdgePipelineMagritteSourceInputIdentifier {
    eddieEdgePipelineRid?: EddieEdgePipelineRid | null | undefined;
    magritteSourceRid: MagritteSourceRid;
    magritteSourceType?: MagritteSourceType | null | undefined;
    magritteTaskType?: EdgeMagritteTaskType | null | undefined;
}
/**
 * This will allow users to configure magritte source configuration for the edge pipeline
 */
interface EdgePipelineMagritteSourceInputShape {
    about: LocalizedTitleAndDescription;
    datasetRid?: EddieEdgePipelineInputDatasetRid | null | undefined;
    magritteSourceType: MagritteSourceType;
    magritteTaskType?: EdgeMagritteTaskType | null | undefined;
}
/**
 * A identifier used when merging resolved shapes to determine if a breaking change has occurred and the resolved
 * shape needs to be redefined.
 *
 * See more details on state of parameter shapes in https://palantir.quip.com/CPnMAn3dndba.
 */
interface EdgePipelineMagritteSourceShapeMergeKey {
    datasetRid?: EddieEdgePipelineInputDatasetRid | null | undefined;
    magritteSourceRid?: MagritteSourceRid | null | undefined;
}
interface EditBlockSetInstallationAllowance_allowed {
    type: "allowed";
    allowed: Void;
}
interface EditBlockSetInstallationAllowance_disallowed {
    type: "disallowed";
    disallowed: EditBlockSetInstallationDisallowed;
}
type EditBlockSetInstallationAllowance = EditBlockSetInstallationAllowance_allowed | EditBlockSetInstallationAllowance_disallowed;
interface EditBlockSetInstallationDisallowed {
    rationales: Array<BlockSetInstallationAccessDisallowedRationale>;
}
interface EditBlockSetInstallationSettingsAllowance_allowed {
    type: "allowed";
    allowed: Void;
}
interface EditBlockSetInstallationSettingsAllowance_disallowed {
    type: "disallowed";
    disallowed: EditBlockSetInstallationSettingsDisallowed;
}
type EditBlockSetInstallationSettingsAllowance = EditBlockSetInstallationSettingsAllowance_allowed | EditBlockSetInstallationSettingsAllowance_disallowed;
interface EditBlockSetInstallationSettingsDisallowed {
    rationale: EditBlockSetInstallationsPermissionDeniedRationale;
}
interface EditBlockSetInstallationsPermissionDeniedRationale {
    blockSetInstallationRids: Array<BlockSetInstallationRid>;
}
/**
 * Request to edit an existing product group.
 */
interface EditProductGroupRequest {
    latestProductGroupVersionRid: ProductGroupVersionRid;
    members: Array<UnresolvedProductGroupMember>;
    validationSettings?: ProductGroupValidationSettings | null | undefined;
}
interface EditProductGroupResponse {
    productGroup: ProductGroup;
}
/**
 * The resolved edits support for the Object Type / ManyToMany Link is incompatible with what is required.
 */
interface EditsSupportIncompatible {
    actual: OutputEditsSupport;
    required: InputEditsSupport;
}
interface EditsViewCreateBlockRequest {
    endTransactionRid?: string | null | undefined;
    rid: string;
}
interface EmailDecodeFormat_eml {
    type: "eml";
    eml: EmlFormat;
}
type EmailDecodeFormat = EmailDecodeFormat_eml;
interface EmailSchema {
    format: EmailDecodeFormat;
}
interface EmlFormat {
}
interface Empty {
}
type EnrollmentCreationStateMachineId = string;
type EnrollmentRid = string;
/**
 * Copy of com.palantir.intoto.dsse.Envelope.
 */
interface Envelope {
    payload: string;
    signatures: Array<Signature>;
    type: string;
}
/**
 * Every reference in this set mapped to the same action type parameter at packaging time
 */
type EquivalentInputActionTypeParameterShapeReferences = Array<BlockSetInputActionTypeParameterReference>;
interface EquivalentInputReferences_equivalentInputShapeReferences {
    type: "equivalentInputShapeReferences";
    equivalentInputShapeReferences: EquivalentInputShapeReferences;
}
interface EquivalentInputReferences_equivalentInputActionTypeParameterShapeReferences {
    type: "equivalentInputActionTypeParameterShapeReferences";
    equivalentInputActionTypeParameterShapeReferences: EquivalentInputActionTypeParameterShapeReferences;
}
type EquivalentInputReferences = EquivalentInputReferences_equivalentInputShapeReferences | EquivalentInputReferences_equivalentInputActionTypeParameterShapeReferences;
/**
 * Every reference in this set mapped to the same resource at packaging time
 */
type EquivalentInputShapeReferences = Array<BlockSetInputBlockShapeReference>;
interface ErrorArg {
    isSafeForLogging: boolean;
    name: string;
    value: string;
}
interface ErrorGranularOutputSpecResult {
    blockType: BlockType;
    errors: OutputSpecErrors;
}
type ErrorInstanceId = string;
/**
 * Attaches an associated error level with the validation error. Warn level errors will display to users, but
 * are non blocking. Blocking errors will disallow packaging.
 */
type ErrorLevel = "WARN" | "BLOCKING";
interface ErrorProductGroupValidationStatus {
}
type ErrorSeverity = "BLOCKING" | "NON_BLOCKING";
/**
 * Creates an evaluation suite block based on the latest version of the evaluation suite
 */
interface EvaluationSuiteCreateBlockRequest {
    evaluationSuiteRid: string;
    evaluationSuiteVersion?: string | null | undefined;
}
interface EvaluationSuiteIdentifier {
    rid: EvaluationSuiteRid;
}
type EvaluationSuiteRid = string;
interface EvaluationSuiteShape {
    about: LocalizedTitleAndDescription;
}
interface ExistingAssociatedBlockSetInstallation {
    blockSetInstallationRid: BlockSetInstallationRid;
    blockSetVersionId: BlockSetVersionId;
    displayMetadata: BlockSetInstallationDisplayMetadata;
    mapping: Record<BlockSetBlockInstanceId, BlockReference>;
}
/**
 * The project or folder rid to install a Blockset.
 */
interface ExistingFolder {
    folderRid: CompassFolderRid;
}
interface ExistingFolderV2 {
    folderRid: CompassFolderRid;
}
interface ExpectedDefaultNotEqualToActualDefault {
    actual: ResolvedBlockSetInputShape;
    expected: ResolvedBlockSetInputShape;
}
interface ExpectedDefaultNotEqualToActualDefaultV2 {
    actual?: ResolvedBlockSetInputShape | null | undefined;
    expected: ResolvedBlockSetInputShape;
}
/**
 * We expected an interface type as the linked entity, but the resolved shape had an object type as the linked
 * entity.
 */
interface ExpectedLinkedInterfaceButWasObject {
    actual: ObjectTypeId;
    expected: InterfaceTypeReference;
}
/**
 * We expected an object type as the linked entity, but the resolved shape had an interface type as the linked
 * entity.
 */
interface ExpectedLinkedObjectButWasInterface {
    actual: InterfaceTypeRid;
    expected: ObjectTypeReference;
}
interface ExpirationStrategy_fixedDate {
    type: "fixedDate";
    fixedDate: Void;
}
interface ExpirationStrategy_relativeDate {
    type: "relativeDate";
    relativeDate: Void;
}
type ExpirationStrategy = ExpirationStrategy_fixedDate | ExpirationStrategy_relativeDate;
interface ExplicitInputShapeRequest {
    metadata?: InputShapeMetadata | null | undefined;
    shape: InputShape;
}
/**
 * Same as `InputShapeResult`, but without a resolved counterpart since these \
 * are provided by the user as-is.
 */
interface ExplicitInputShapeResult {
    blockShapeId: BlockShapeId;
    internalShapeId: InternalShapeId;
    metadata: InputShapeMetadata;
    shape: InputShape;
}
interface ExplicitProvenance {
    outputSpec?: OutputSpec | null | undefined;
}
interface ExportBlockRequest {
    fileType?: ExportBlockRequestFileType | null | undefined;
}
interface ExportBlockRequestFileType_zip {
    type: "zip";
    zip: ExportBlockRequestFileTypeZip;
}
type ExportBlockRequestFileType = ExportBlockRequestFileType_zip;
interface ExportBlockRequestFileTypeZip {
    compressionLevel?: number | null | undefined;
}
interface ExportBlockSetRequest {
}
/**
 * If the preset is compatible with exporting across stacks.
 *
 * If it is COMPATIBLE, then it should be possible to export the blockSet to another stack and to have the preset
 * resolution work as expected. This may typically happen if the preset does not refer to any stack-specific
 * resource identifiers, such as a `ApiNameResolver`.
 *
 * If it is INCOMPATIBLE, then the preset will fail to resolve if the blockSet is imported into another stack
 * or tenant. If the preset is MANDATORY, this will make the blockSet undeployable. If the preset is
 * SUGGESTED, installers will have the option to provide their own resolved shape instead.
 */
type ExportCompatibility = "COMPATIBLE" | "INCOMPATIBLE";
interface ExportMultipleBlockSetsRequest {
    blockSetVersions: Array<BlockSetVersionId>;
}
/**
 * Reasons why the user is not allowed to export from the Marketplace Store.
 */
type ExportPermissionDeniedReason = "MARKETPLACE_READ_LOCAL_MARKETPLACE_MISSING_OPERATION" | "MARKETPLACE_EXPORT_BLOCK_SET_MISSING_OPERATION" | "EXPORT_DISABLED_QUOTA";
/**
 * An input that was provided by an external recommendation from an output of another block set installation.
 */
interface ExternallyRecommendedOutput {
    type: BlockSetInstallationOutputReference;
}
/**
 * An input that was provided by an external recommendation from an output of another block set installation.
 */
interface ExternallyRecommendedOutputV2 {
    outputReference: BlockSetInstallationOutputReference;
    resolvedInput?: ResolvedBlockSetInputShape | null | undefined;
}
interface ExternalRecommendationDisplayMetadata {
    installationVisibility: ExternalRecommendationInstallationVisibility;
}
interface ExternalRecommendationInstallationVisibility_enabled {
    type: "enabled";
    enabled: Void;
}
interface ExternalRecommendationInstallationVisibility_disabled {
    type: "disabled";
    disabled: Void;
}
interface ExternalRecommendationInstallationVisibility_featured {
    type: "featured";
    featured: Void;
}
/**
 * Sets the visibility of a given upstream block set recommendation. Does not gate usage of the recommendation
 * during installations.
 */
type ExternalRecommendationInstallationVisibility = ExternalRecommendationInstallationVisibility_enabled | ExternalRecommendationInstallationVisibility_disabled | ExternalRecommendationInstallationVisibility_featured;
interface ExternalRecommendationMavenDependencyRequirement_required {
    type: "required";
    required: Void;
}
interface ExternalRecommendationMavenDependencyRequirement_optional {
    type: "optional";
    optional: Void;
}
interface ExternalRecommendationMavenDependencyRequirement_ignored {
    type: "ignored";
    ignored: Void;
}
/**
 * Controls the maven dependency requirements for an external recommendation of an upstream marketplace product.
 * The requirement is applied to upstream products associated with a maven id when the downstream product is
 * packaged.
 */
type ExternalRecommendationMavenDependencyRequirement = ExternalRecommendationMavenDependencyRequirement_required | ExternalRecommendationMavenDependencyRequirement_optional | ExternalRecommendationMavenDependencyRequirement_ignored;
interface ExternalRecommendationSource_owned {
    type: "owned";
    owned: Void;
}
interface ExternalRecommendationSource_ownedPending {
    type: "ownedPending";
    ownedPending: OwnedPendingRecommendationSource;
}
interface ExternalRecommendationSource_otherStoreLocal {
    type: "otherStoreLocal";
    otherStoreLocal: OtherStoreLocalRecommendationSource;
}
interface ExternalRecommendationSource_otherStoreRemote {
    type: "otherStoreRemote";
    otherStoreRemote: Void;
}
interface ExternalRecommendationSource_upstreamInstallationLocal {
    type: "upstreamInstallationLocal";
    upstreamInstallationLocal: LocalUpstreamInstallationRecommendationSource;
}
interface ExternalRecommendationSource_upstreamInstallationRemote {
    type: "upstreamInstallationRemote";
    upstreamInstallationRemote: Void;
}
/**
 * Information about the "source" of an external recommendation, i.e. how it was generated.
 */
type ExternalRecommendationSource = ExternalRecommendationSource_owned | ExternalRecommendationSource_ownedPending | ExternalRecommendationSource_otherStoreLocal | ExternalRecommendationSource_otherStoreRemote | ExternalRecommendationSource_upstreamInstallationLocal | ExternalRecommendationSource_upstreamInstallationRemote;
interface ExternalRecommendationToSelf {
    installation: BlockSetReference;
}
/**
 * An external recommendation was used for input, but input has
 * mandatory presets. This is disallowed.
 */
interface ExternalRecommendationUsedForInputShapeWithMandatoryPresets {
}
/**
 * Backend generated recommendation from a block set -> block set version over a compatible version range
 */
interface ExternalRecommendationV2 {
    displayMetadata?: ExternalRecommendationDisplayMetadata | null | undefined;
    mappings: Array<InputRecommendationV2>;
    mavenProductDependencyRequirement?: ExternalRecommendationMavenDependencyRequirement | null | undefined;
    source: ExternalRecommendationSource;
    targetBlockSet?: BlockSetId | null | undefined;
    targetBlockSetVersion: BlockSetVersionId;
    targetMarketplaceRid?: MarketplaceRid | null | undefined;
    upstreamBlockSet: BlockSetId;
    upstreamMavenProductId?: MavenProductId | null | undefined;
    upstreamVersionCompatability: BlockSetVersionRange;
}
/**
 * An integrating service returned an unexpected error response.
 */
interface ExternalServiceError {
    blockType?: BlockType | null | undefined;
    error?: MarketplaceSerializableError | null | undefined;
    errorInstanceId?: string | null | undefined;
    message: string;
}
/**
 * Some constraints are preventing the automation from making progress.
 */
interface FailedConstraintsStatus {
    constraintFailures: ConstraintFailures;
}
interface FailedInstallBlocksResponse {
    jobSubmissionFailure?: JobSubmissionFailure | null | undefined;
    reason: string;
}
interface FailedToDeleteResourcesError {
    failedToDeleteResources: Record<BlockShapeId, ResolvedOutputShape>;
}
interface FailedToSubmitJobResult {
    jobSubmissionFailure?: JobSubmissionFailure | null | undefined;
    reason: string;
}
/**
 * The original name of the file that was uploaded, including the file ending, e.g. "file.pdf".
 */
type Filename = string;
interface FilesDatasourceInputIdentifier {
    datasource?: DatasetLocator | null | undefined;
    datasourceLocator?: FilesDatasourceLocator | null | undefined;
    supportedTypes?: Array<FilesDatasourceInputType> | null | undefined;
}
interface FilesDatasourceInputShape {
    about: LocalizedTitleAndDescription;
    supportedTypes?: Array<FilesDatasourceInputType> | null | undefined;
}
interface FilesDatasourceInputType_dataset {
    type: "dataset";
    dataset: Void;
}
interface FilesDatasourceInputType_mediaSet {
    type: "mediaSet";
    mediaSet: MediaSetDatasourceType;
}
type FilesDatasourceInputType = FilesDatasourceInputType_dataset | FilesDatasourceInputType_mediaSet;
interface FilesDatasourceLocator_dataset {
    type: "dataset";
    dataset: DatasetLocator;
}
interface FilesDatasourceLocator_mediaSet {
    type: "mediaSet";
    mediaSet: MediaSetLocator;
}
type FilesDatasourceLocator = FilesDatasourceLocator_dataset | FilesDatasourceLocator_mediaSet;
interface FilesDatasourceOutputIdentifier {
    buildRequirements?: DatasourceBuildRequirements | null | undefined;
    datasource?: DatasetLocator | null | undefined;
    datasourceLocator?: FilesDatasourceLocator | null | undefined;
}
interface FilesDatasourceOutputShape {
    about: LocalizedTitleAndDescription;
    buildRequirements?: DatasourceBuildRequirements | null | undefined;
    datasourceType?: FilesDatasourceOutputType | null | undefined;
}
interface FilesDatasourceOutputType_dataset {
    type: "dataset";
    dataset: Void;
}
interface FilesDatasourceOutputType_mediaSet {
    type: "mediaSet";
    mediaSet: MediaSetDatasourceType;
}
type FilesDatasourceOutputType = FilesDatasourceOutputType_dataset | FilesDatasourceOutputType_mediaSet;
type FilesDatasourceReference = BlockInternalId;
/**
 * A dataset was provided as input, but the files datasource input shape only supports media sets.
 * Opposite of `BlockInstallMediaSetNotSupported`.
 */
interface FilesDatasourceTypeNotSupported {
}
type FileSizeInBytes = number;
/**
 * Reference a file in an artifacts files layout.
 */
interface FilesLocator {
    path: string;
}
interface FinalizeBlockSetVersionRequest {
    semverOverride?: SemverVersion | null | undefined;
}
interface FinalizeBlockSetVersionResponse {
}
interface FinalizedBlockSetVersionStatus {
}
interface FinalizeDraftGroupRequest {
}
interface FinalizeDraftGroupResponse {
    alreadyFinalized: Array<BlockSetVersionId>;
    willBeFinalized: Array<BlockSetVersionId>;
}
interface FinalizedStatusV3 {
}
interface FinalizingStatusV3 {
}
interface FinishedInstallPendingStatus {
    blockShapeBuildMetadata: Record<BlockShapeId, BlockShapeBuildMetadata>;
    buildsAndIndexingIds: Record<BlockShapeId, BuildsAndIndexingIds>;
}
interface FlacFormat {
}
interface FlinkProfileIdentifier {
    name: FlinkProfileName;
}
type FlinkProfileName = string;
interface FlinkProfileShape {
    about: LocalizedTitleAndDescription;
}
/**
 * A folder input was provided through an external recommendation. This is not allowed if the folder has an
 * `INSTALL_LOCATION` constraint.
 */
interface FolderInputExternallyRecommended {
    blockSetReference: BlockSetReference;
    outputShapeId: OutputBlockSetShapeId;
}
/**
 * A folder that was passed as an input was not the installation folder. This is not allowed if the
 * folder has an `INSTALL_LOCATION` constraint.
 *
 * If `installationFolderRid` is empty and the input is optional, the input should be excluded from the request.
 *
 * If `installationFolderRid` is empty and the input is required, the installation needs to be done into an
 * existing folder instead of having Marketplace create the project as part of the installation.
 */
interface FolderInputNotSetToInstallationFolder {
    inputFolderRid: CompassFolderRid;
    installationFolderRid?: CompassFolderRid | null | undefined;
    isOptional: boolean;
}
/**
 * The given folder inputs require installing into an existing folder, but the installation mode of the block
 * set version is set to a mode that only allows installing into a new project. To fix this, the installation
 * mode should be changed to "bootstrap".
 */
interface FolderInputPreventsInstallingInNewProject {
    inputShapeIds: Array<InputBlockSetShapeId>;
}
/**
 * There was a folder input with constraints that only support mapping the input to the root folder for the
 * installation folder. In this case we only support installing into an existing folder.
 */
interface FolderInputRequiresInstallingIntoExistingFolder {
}
/**
 * Creates a foundry peering producer profile block for the given peer producer profile rid
 */
interface FoundryPeerProducerProfileCreateBlockRequest {
    peerProducerProfileRid: string;
}
interface FoundryProductsDownloaderStore {
    apolloCrossStackManifest: ApolloCrossStackManifest;
    apolloSpaceId?: ApolloSpaceId | null | undefined;
    deprecateAllUnlistedProducts?: boolean | null | undefined;
    products: Array<MavenProductIdOrCoordinate>;
}
interface FreeFormDocumentation_markdown {
    type: "markdown";
    markdown: MarkdownText;
}
type FreeFormDocumentation = FreeFormDocumentation_markdown;
interface FreeFormDocumentationSection {
    freeForm: FreeFormDocumentation;
    key: string;
    title: string;
}
/**
 * A list of Markdown documentation entries, each enriched with a section title and key. This enables opinionated
 * organization and rendering of the documentation.
 */
interface FreeFormDocumentationSections {
    freeFormSections: Array<FreeFormDocumentationSection>;
}
/**
 * An input that was resolved from the default value declared on the shape during packaging.
 */
interface FromDefaultInput {
    resolvedDefault: ResolvedBlockSetInputShape;
}
interface FromSourceResolvedPresetValue {
    resultForShape: ResolvedShapeResolutionResultUnion;
}
interface FunctionApiName_ontologyBound {
    type: "ontologyBound";
    ontologyBound: OntologyBoundFunctionApiNameAndBinding;
}
interface FunctionApiName_global {
    type: "global";
    global: GlobalFunctionApiName;
}
type FunctionApiName = FunctionApiName_ontologyBound | FunctionApiName_global;
interface FunctionConfigurationIdentifier {
    functionRid: FunctionRid;
    functionVersion: FunctionVersion;
}
/**
 * A synthethic RID derived from the rid of the function this configuration applies to.
 */
type FunctionConfigurationRid = string;
interface FunctionConfigurationsCreateBlockRequest {
    functionRids: Array<FunctionRid>;
    version: string;
}
interface FunctionConfigurationShape {
    about: LocalizedTitleAndDescription;
    function: FunctionReference;
}
type FunctionContractApiName = string;
interface FunctionContractApiNameIdentifier {
    apiName: FunctionContractApiName;
    version?: FunctionContractVersion | null | undefined;
}
interface FunctionContractIdentifier_rid {
    type: "rid";
    rid: FunctionContractRidIdentifier;
}
interface FunctionContractIdentifier_apiName {
    type: "apiName";
    apiName: FunctionContractApiNameIdentifier;
}
/**
 * Identifier for specifying how a contracts shape should be generated.
 */
type FunctionContractIdentifier = FunctionContractIdentifier_rid | FunctionContractIdentifier_apiName;
/**
 * The function input had a contract requirement that was not fulfilled by the given function.
 */
interface FunctionContractNotImplemented {
    actualContracts: Array<FunctionContractRid>;
    requiredContract: FunctionContractRid;
}
type FunctionContractReference = BlockInternalId;
type FunctionContractRid = string;
interface FunctionContractRidIdentifier {
    rid: FunctionContractRid;
    version?: FunctionContractVersion | null | undefined;
}
interface FunctionContractShape {
    about: LocalizedTitleAndDescription;
    apiName: FunctionContractApiName;
    version: FunctionContractVersion;
}
interface FunctionContractsIdentifier_all {
    type: "all";
    all: Void;
}
interface FunctionContractsIdentifier_subset {
    type: "subset";
    subset: Array<FunctionContractIdentifier>;
}
interface FunctionContractsIdentifier_expression {
    type: "expression";
    expression: ContractExpressionIdentifier;
}
interface FunctionContractsIdentifier_none {
    type: "none";
    none: Void;
}
/**
 * Identifier for specifying how the `contracts` field should be populated on the functions shape.
 */
type FunctionContractsIdentifier = FunctionContractsIdentifier_all | FunctionContractsIdentifier_subset | FunctionContractsIdentifier_expression | FunctionContractsIdentifier_none;
/**
 * This version is enforced to be a semver string.
 */
type FunctionContractVersion = string;
type FunctionContractVersionReference = BlockInternalId;
/**
 * The Function DataType is referencing ActionTypeRid(s) as a parameter, which is not supported by the
 * marketplace integration.
 */
interface FunctionCustomTypeDataTypeActionTypeReferencesNotSupported {
    actionTypeRids: Array<ActionTypeRid>;
    customTypeId: CustomTypeId;
    fieldName: CustomTypeFieldName;
}
/**
 * The DataType of the output for the specified Function uses a custom type but the custom type definition
 * was not found on the FunctionSpec retrieved from Functions Registry.
 */
interface FunctionCustomTypeDataTypeCustomTypeNotFound {
    customTypeId: CustomTypeId;
    customTypeIdsFound: Array<CustomTypeId>;
    fieldName: CustomTypeFieldName;
    missingCustomTypeId: CustomTypeId;
}
/**
 * The Function DataType is referencing an InterfaceTypeRid for which the shape id could not be resolved.
 * This is typical if the referenced InterfaceType has not been included as an input/output in the block.
 */
interface FunctionCustomTypeDataTypeInterfaceTypeUnresolvable {
    customTypeId: CustomTypeId;
    fieldName: CustomTypeFieldName;
    interfaceTypeRid: InterfaceTypeRid;
}
/**
 * The DataType of a custom type for the specified function uses an unknown Marking subtype.
 */
interface FunctionCustomTypeDataTypeMarkingSubTypeUnknown {
    customTypeId: CustomTypeId;
    fieldName: CustomTypeFieldName;
    subType: string;
}
/**
 * The Function DataType is referencing an ObjectTypeId for which the shape id could not be resolved.
 * This is typical if the referenced ObjectType has not been included as an input/output in the block.
 */
interface FunctionCustomTypeDataTypeObjectTypeUnresolvable {
    customTypeId: CustomTypeId;
    fieldName: CustomTypeFieldName;
    objectTypeId: ObjectTypeId;
}
/**
 * The DataType of a custom type for the specified function uses an unknown Marking subtype.
 */
interface FunctionCustomTypeDataTypeUnknown {
    customTypeId: CustomTypeId;
    fieldName: CustomTypeFieldName;
    subType: string;
}
interface FunctionDataTypeValueTypeUnresolvable {
    valueTypeRid: ValueTypeRid;
    valueTypeVersion?: ValueTypeVersion | null | undefined;
}
interface FunctionDataTypeValueTypeUnresolvableV2 {
    valueTypeRid: ValueTypeRid;
    valueTypeVersionId?: ValueTypeVersionId | null | undefined;
}
/**
 * The function does not satisfy the ContractExpression requirement specified in the function input shape.
 * This validation ensures that functions implement the necessary contracts (single, AND, or OR expressions).
 */
interface FunctionDoesNotSatisfyContractExpression {
    expression: ContractExpression;
    implementedContracts: Array<FunctionContractRid>;
}
/**
 * The DataType of the input for the specified Function is of an unknown type and maps to an input name not present on the function input shape.
 */
interface FunctionExtraInputDataTypeUnknown {
    inputName: string;
    type: string;
}
/**
 * The Function DataType is referencing ActionTypeRid(s) as a parameter, which is not supported by the
 * marketplace integration.
 */
interface FunctionInputDataTypeActionTypeReferencesUnsupported {
    actionTypeRids: Array<ActionTypeRid>;
    inputIndex: number;
}
/**
 * The Function DataType is referencing ActionTypeRid(s) as a parameter, which is not supported by the
 * marketplace integration.
 */
interface FunctionInputDataTypeActionTypeReferencesUnsupportedV2 {
    actionTypeRids: Array<ActionTypeRid>;
    inputName: string;
}
/**
 * The DataType of the input for the specified Function uses a custom type but the custom type definition
 * was not found on the FunctionSpec retrieved from Functions Registry.
 */
interface FunctionInputDataTypeCustomTypeNotFound {
    customTypeId: CustomTypeId;
    customTypeIdsFound: Array<CustomTypeId>;
    inputIndex: number;
}
/**
 * The DataType of the input for the specified Function uses a custom type but the custom type definition
 * was not found on the FunctionSpec retrieved from Functions Registry.
 */
interface FunctionInputDataTypeCustomTypeNotFoundV2 {
    customTypeId: CustomTypeId;
    customTypeIdsFound: Array<CustomTypeId>;
    inputName: string;
}
/**
 * The Function input DataType is referencing an InterfaceTypeRid for which the shape id could not be resolved.
 * This is typical if the referenced InterfaceType has not been included as an input/output in the block.
 */
interface FunctionInputDataTypeInterfaceTypeRidUnresolvable {
    inputName: string;
    interfaceTypeRid: InterfaceTypeRid;
}
/**
 * The DataType of the input for the specified function uses an unknown Marking subtype.
 */
interface FunctionInputDataTypeMarkingSubTypeUnknown {
    inputIndex: number;
    subType: string;
}
/**
 * The DataType of the input for the specified function uses an unknown Marking subtype.
 */
interface FunctionInputDataTypeMarkingSubTypeUnknownV2 {
    inputName: string;
    subType: string;
}
/**
 * The DataType of the input for the specified Function does not match the expected type.
 */
interface FunctionInputDataTypeMismatch {
    actual: DataType$1;
    expected: DataType$1;
    inputIndex: number;
}
/**
 * The DataType of the input for the specified Function does not match the expected type.
 */
interface FunctionInputDataTypeMismatchV2 {
    actual: DataType$1;
    expected: DataType$1;
    inputName: string;
}
/**
 * The Function input DataType is referencing an ObjectTypeId for which the shape id could not be resolved.
 * This is typical if the referenced ObjectType has not been included as an input/output in the block.
 */
interface FunctionInputDataTypeObjectTypeIdUnresolvable {
    inputIndex: number;
    objectTypeId: ObjectTypeId;
}
/**
 * The Function input DataType is referencing an ObjectTypeId for which the shape id could not be resolved.
 * This is typical if the referenced ObjectType has not been included as an input/output in the block.
 */
interface FunctionInputDataTypeObjectTypeIdUnresolvableV2 {
    inputName: string;
    objectTypeId: ObjectTypeId;
}
/**
 * The DataType of the input for the specified Function is of an unknown type.
 */
interface FunctionInputDataTypeUnknown {
    expected: DataType$1;
    inputIndex: number;
    type: string;
}
/**
 * The DataType of the input for the specified Function is of an unknown type.
 */
interface FunctionInputDataTypeUnknownV2 {
    expected: DataType$1;
    inputName: string;
    type: string;
}
interface FunctionInputIdentifier_rid {
    type: "rid";
    rid: FunctionRidIdentifier;
}
interface FunctionInputIdentifier_ridAndVersion {
    type: "ridAndVersion";
    ridAndVersion: FunctionRidAndVersionRangeIdentifier;
}
interface FunctionInputIdentifier_languageModelRid {
    type: "languageModelRid";
    languageModelRid: FunctionLanguageModelRidIdentifier;
}
interface FunctionInputIdentifier_staticInput {
    type: "staticInput";
    staticInput: FunctionStaticInputIdentifier;
}
type FunctionInputIdentifier = FunctionInputIdentifier_rid | FunctionInputIdentifier_ridAndVersion | FunctionInputIdentifier_languageModelRid | FunctionInputIdentifier_staticInput;
type FunctionInputName = string;
/**
 * A function input name did not match the expected input name. Input names must match those in the shape.
 */
interface FunctionInputNamesDiffer {
    actualInputName: FunctionInputName;
    expectedInputName: FunctionInputName;
    inputIndex: number;
}
/**
 * A function input that was referenced in the Function shape was not found on the actual Function.
 */
interface FunctionInputNotFound {
    expected: FunctionInputType;
    inputIndex: number;
}
/**
 * A function input that was referenced in the Function shape was not found on the actual Function.
 */
interface FunctionInputNotFoundV2 {
    expected: FunctionInputType;
    inputName: string;
}
/**
 * A function input which is expected to be optional as per the declared Function shape is marked as required on the actual Function.
 */
interface FunctionInputNotOptional {
    inputIndex: number;
}
/**
 * A function input which is expected to be optional as per the declared Function shape is marked as required on the actual Function.
 */
interface FunctionInputNotOptionalV2 {
    inputName: string;
}
interface FunctionInputShape {
    about: LocalizedTitleAndDescription;
    contractRequirement?: ContractExpression | null | undefined;
    contracts: Array<FunctionContractReference>;
    customTypes: Record<CustomTypeId, CustomType>;
    inputs: Array<FunctionInputType>;
    output: FunctionOutputType;
    stableId?: FunctionShapeStableId | null | undefined;
}
interface FunctionInputType {
    about: LocalizedTitleAndDescription;
    dataType: DataType$1;
    inputName?: FunctionInputName | null | undefined;
    required: boolean;
}
interface FunctionInputTypeDisplayMetadata {
    about: LocalizedTitleAndDescription;
}
/**
 * Identifier for generating an input shape for a function that wraps an LMS model. All contracts from the
 * underlying function will be included on the shape.
 */
interface FunctionLanguageModelRidIdentifier {
    languageModelRid: LanguageModelRid;
}
interface FunctionNotFound {
    functionRid: FunctionRid;
}
/**
 * The Function DataType is referencing ActionTypeRid(s) as a parameter, which is not supported by the
 * marketplace integration.
 */
interface FunctionOutputDataTypeActionTypeReferencesUnsupported {
    actionTypeRids: Array<ActionTypeRid>;
}
/**
 * The DataType of the output for the specified Function uses a custom type but the custom type definition
 * was not found on the FunctionSpec retrieved from Functions Registry.
 */
interface FunctionOutputDataTypeCustomTypeNotFound {
    customTypeId: CustomTypeId;
    customTypeIdsFound: Array<CustomTypeId>;
}
/**
 * The Function DataType is referencing an InterfaceTypeRid for which the shape id could not be resolved.
 * This is typical if the referenced InterfaceType has not been included as an input/output in the block.
 */
interface FunctionOutputDataTypeInterfaceTypeRidUnresolvable {
    objectTypeId: InterfaceTypeRid;
}
/**
 * The DataType of the output for the specified function uses an unknown Marking subtype.
 */
interface FunctionOutputDataTypeMarkingSubTypeUnknown {
    subType: string;
}
/**
 * The DataType of the output for the specified Function does not match the expected type.
 */
interface FunctionOutputDataTypeMismatch {
    actual: DataType$1;
    expected: DataType$1;
}
/**
 * The Function DataType is referencing an ObjectTypeId for which the shape id could not be resolved.
 * This is typical if the referenced ObjectType has not been included as an input/output in the block.
 */
interface FunctionOutputDataTypeObjectTypeIdUnresolvable {
    objectTypeId: ObjectTypeId;
}
/**
 * The DataType of the output for the specified Function is of an unknown type.
 */
interface FunctionOutputDataTypeUnknown {
    expected: DataType$1;
    type: string;
}
interface FunctionOutputIdentifier_rid {
    type: "rid";
    rid: FunctionRidOutputIdentifier;
}
interface FunctionOutputIdentifier_ridAndVersion {
    type: "ridAndVersion";
    ridAndVersion: FunctionRidAndVersionIdentifier;
}
type FunctionOutputIdentifier = FunctionOutputIdentifier_rid | FunctionOutputIdentifier_ridAndVersion;
interface FunctionOutputShape {
    about: LocalizedTitleAndDescription;
    contracts: Array<FunctionContractReference>;
    customTypes: Record<CustomTypeId, CustomType>;
    inputs: Array<FunctionInputType>;
    output: FunctionOutputType;
}
interface FunctionOutputType_singleOutputType {
    type: "singleOutputType";
    singleOutputType: SingleOutputType;
}
interface FunctionOutputType_voidOutputType {
    type: "voidOutputType";
    voidOutputType: VoidOutputType;
}
type FunctionOutputType = FunctionOutputType_singleOutputType | FunctionOutputType_voidOutputType;
interface FunctionOutputTypeDisplayMetadata_singleOutputType {
    type: "singleOutputType";
    singleOutputType: SingleOutputTypeDisplayMetadata;
}
type FunctionOutputTypeDisplayMetadata = FunctionOutputTypeDisplayMetadata_singleOutputType;
/**
 * The function output type for the specified function does not match the expected type. This error occurs
 * if a void type was expected but a single output type was provided, or vice versa.
 */
interface FunctionOutputTypeMismatch {
    actual: FunctionOutputType;
    expected: FunctionOutputType;
}
/**
 * The OutputType for the specified Function is unknown.
 */
interface FunctionOutputTypeUnknown {
    expected: FunctionOutputType;
    type: string;
}
interface FunctionPackageCandidateIdentifier {
    functionRid: FunctionRid;
    functionVersion: FunctionVersion;
}
/**
 * This block packages deployment configurations for container-backed functions. These configurations are set at the package level.
 * The configuration controls how the function's containerized deployment is started, upgraded, and managed. This includes the deployment
 * mode (e.g., deployed vs serverless), resource configurations (CPU, memory), and specifying what container images should be run.
 *
 * At reconcile time, the package configuration block needs to start up/upgrade a deployment for functions (if the functions are configured to be in deployed mode).
 * To do that, it needs to know what container images should be run in said deployment and what other (non-user-facing) configurations should set on the containerized
 * application. This information requires loading at least one of the function specs that will be backed by the deployment.
 *
 * Because of this, we have to declare a function input (with reconcile access requirement) on the package configuration block. This allows us to load the function
 * spec at reconcile time and extract the information needed to start/upgrade the deployment. Hence, the create-block request must provide at least one function
 * RID/version that is backed by the deployment whose package configurations are being packaged.
 */
interface FunctionPackageCandidateLocator {
    functionRid: FunctionRid;
    version: string;
}
interface FunctionPackageConfigurationCreateBlockRequest {
    packageLocator: FunctionPackageLocator;
}
interface FunctionPackageConfigurationIdentifier_candidateFunction {
    type: "candidateFunction";
    candidateFunction: FunctionPackageCandidateIdentifier;
}
type FunctionPackageConfigurationIdentifier = FunctionPackageConfigurationIdentifier_candidateFunction;
/**
 * A synthetic RID derived from a function that is backed by the relevant deployment.
 */
type FunctionPackageConfigurationRid = string;
interface FunctionPackageConfigurationShape {
    about: LocalizedTitleAndDescription;
    packageReference: FunctionPackageShapeReference;
}
interface FunctionPackageLocator_candidateFunction {
    type: "candidateFunction";
    candidateFunction: FunctionPackageCandidateLocator;
}
type FunctionPackageLocator = FunctionPackageLocator_candidateFunction;
interface FunctionPackageShapeReference_repository {
    type: "repository";
    repository: AuthoringRepositoryReference;
}
type FunctionPackageShapeReference = FunctionPackageShapeReference_repository;
type FunctionReference = BlockInternalId;
type FunctionRid = string;
/**
 * Identifier for generating an output shape for a function at a version.
 */
interface FunctionRidAndVersionIdentifier {
    rid: FunctionRid;
    version: FunctionVersion;
}
/**
 * Identifier for generating an input shape for a function at a semantic version range.
 */
interface FunctionRidAndVersionRangeIdentifier {
    contracts?: FunctionContractsIdentifier | null | undefined;
    rid: FunctionRid;
    version: FunctionVersionRange;
}
/**
 * Identifier for generating an input shape for the latest version of a function.
 */
interface FunctionRidIdentifier {
    contracts?: FunctionContractsIdentifier | null | undefined;
    rid: FunctionRid;
}
/**
 * Identifier for generating an output shape for the latest version of a function.
 */
interface FunctionRidOutputIdentifier {
    rid: FunctionRid;
}
interface FunctionsApiStabilityConfiguration_deduplicate {
    type: "deduplicate";
    deduplicate: DeduplicateFunctionsApiStabilityConfiguration;
}
interface FunctionsApiStabilityConfiguration_stable {
    type: "stable";
    stable: StableFunctionsApiStabilityConfiguration;
}
type FunctionsApiStabilityConfiguration = FunctionsApiStabilityConfiguration_deduplicate | FunctionsApiStabilityConfiguration_stable;
/**
 * There is only a single instance of this input per block set, which means that ALL function blocks in a block
 * set must have the same API stability configuration (i.e., you can't have some functions that have API
 * stability and others that don't).
 */
interface FunctionsApiStabilityConfigurationInputIdentifier {
}
/**
 * See ResolvedFunctionsApiStabilityConfigurationInputShape for details.
 */
interface FunctionsApiStabilityConfigurationInputShape {
    about: LocalizedTitleAndDescription;
}
/**
 * Not yet implemented by the corresponding service
 */
interface FunctionsCreateBlockRequest {
    functionRids: Array<string>;
    version: string;
}
/**
 * Encountered an error while trying to convert an unresolved function shape to a function signature.
 */
interface FunctionShapeConversionError {
    reasons: Array<FunctionShapeConversionFailedReason>;
}
interface FunctionShapeConversionFailedReason_inputDataTypeConversion {
    type: "inputDataTypeConversion";
    inputDataTypeConversion: FunctionShapeInputDataTypeConversionFailed;
}
interface FunctionShapeConversionFailedReason_outputDataTypeConversion {
    type: "outputDataTypeConversion";
    outputDataTypeConversion: FunctionShapeOutputDataTypeConversionFailed;
}
interface FunctionShapeConversionFailedReason_customTypeDataTypeConversion {
    type: "customTypeDataTypeConversion";
    customTypeDataTypeConversion: FunctionShapeCustomTypeDataTypeConversionFailed;
}
type FunctionShapeConversionFailedReason = FunctionShapeConversionFailedReason_inputDataTypeConversion | FunctionShapeConversionFailedReason_outputDataTypeConversion | FunctionShapeConversionFailedReason_customTypeDataTypeConversion;
/**
 * Encountered an error while trying to convert the data type on an unresolved function shape custom type field.
 */
interface FunctionShapeCustomTypeDataTypeConversionFailed {
    customTypeId: CustomTypeId;
    error: FunctionShapeDataTypeConversionError;
    fieldName: CustomTypeFieldName;
}
interface FunctionShapeDataTypeConversionError_unknownBucketKeyType {
    type: "unknownBucketKeyType";
    unknownBucketKeyType: FunctionShapeUnknownBucketKeyType;
}
interface FunctionShapeDataTypeConversionError_unknownBucketValueType {
    type: "unknownBucketValueType";
    unknownBucketValueType: FunctionShapeUnknownBucketValueType;
}
interface FunctionShapeDataTypeConversionError_unknownDataType {
    type: "unknownDataType";
    unknownDataType: FunctionShapeUnknownDataType;
}
interface FunctionShapeDataTypeConversionError_unknownGeoShapeSubType {
    type: "unknownGeoShapeSubType";
    unknownGeoShapeSubType: FunctionShapeUnknownGeoShapeSubType;
}
interface FunctionShapeDataTypeConversionError_unknownLogicalTypeReferenceType {
    type: "unknownLogicalTypeReferenceType";
    unknownLogicalTypeReferenceType: FunctionShapeUnknownLogicalTypeReference;
}
interface FunctionShapeDataTypeConversionError_unknownMarkingSubType {
    type: "unknownMarkingSubType";
    unknownMarkingSubType: FunctionShapeUnknownMarkingSubType;
}
interface FunctionShapeDataTypeConversionError_unknownRangeType {
    type: "unknownRangeType";
    unknownRangeType: FunctionShapeUnknownRangeType;
}
interface FunctionShapeDataTypeConversionError_unknownTimeSeriesValueType {
    type: "unknownTimeSeriesValueType";
    unknownTimeSeriesValueType: FunctionShapeUnknownTimeSeriesValueType;
}
interface FunctionShapeDataTypeConversionError_unknownVectorElementType {
    type: "unknownVectorElementType";
    unknownVectorElementType: FunctionShapeUnknownVectorElementType;
}
interface FunctionShapeDataTypeConversionError_unresolvableCrossShapeReference {
    type: "unresolvableCrossShapeReference";
    unresolvableCrossShapeReference: FunctionShapeUnresolvableCrossShapeReference;
}
interface FunctionShapeDataTypeConversionError_unsupportedDataType {
    type: "unsupportedDataType";
    unsupportedDataType: FunctionShapeUnsupportedDataType;
}
/**
 * Encountered an error while trying to convert data types on an unresolved function shape.
 */
type FunctionShapeDataTypeConversionError = FunctionShapeDataTypeConversionError_unknownBucketKeyType | FunctionShapeDataTypeConversionError_unknownBucketValueType | FunctionShapeDataTypeConversionError_unknownDataType | FunctionShapeDataTypeConversionError_unknownGeoShapeSubType | FunctionShapeDataTypeConversionError_unknownLogicalTypeReferenceType | FunctionShapeDataTypeConversionError_unknownMarkingSubType | FunctionShapeDataTypeConversionError_unknownRangeType | FunctionShapeDataTypeConversionError_unknownTimeSeriesValueType | FunctionShapeDataTypeConversionError_unknownVectorElementType | FunctionShapeDataTypeConversionError_unresolvableCrossShapeReference | FunctionShapeDataTypeConversionError_unsupportedDataType;
interface FunctionShapeDisplayMetadata {
    about: LocalizedTitleAndDescription;
    inputs: Array<FunctionInputTypeDisplayMetadata>;
    output: FunctionOutputTypeDisplayMetadata;
}
/**
 * Encountered an error while trying to convert the data type on an unresolved function shape input.
 */
interface FunctionShapeInputDataTypeConversionFailed {
    error: FunctionShapeDataTypeConversionError;
    inputName: FunctionInputName;
}
/**
 * Encountered an error while trying to convert the data type on an unresolved function shape output.
 */
interface FunctionShapeOutputDataTypeConversionFailed {
    error: FunctionShapeDataTypeConversionError;
}
/**
 * Encountered an error because the signature of the resolved input function is incompatible with that of the
 * unresolved function shape.
 */
interface FunctionShapeSignatureCompatibilityError {
    reasons: Array<FunctionShapeSignatureIncompatibleReason>;
}
/**
 * The data type of an input on the unresolved shape is not compatible with that of the resolved function.
 */
interface FunctionShapeSignatureIncompatibleInputTypeChange {
    inputName: FunctionInputName;
}
/**
 * The output type on the unresolved shape is not compatible with that of the resolved function.
 */
interface FunctionShapeSignatureIncompatibleOutputTypeChange {
}
interface FunctionShapeSignatureIncompatibleReason_missingInput {
    type: "missingInput";
    missingInput: FunctionShapeSignatureMissingInput;
}
interface FunctionShapeSignatureIncompatibleReason_unknownRequiredInput {
    type: "unknownRequiredInput";
    unknownRequiredInput: FunctionShapeSignatureUnknownRequiredInput;
}
interface FunctionShapeSignatureIncompatibleReason_incompatibleInputTypeChange {
    type: "incompatibleInputTypeChange";
    incompatibleInputTypeChange: FunctionShapeSignatureIncompatibleInputTypeChange;
}
interface FunctionShapeSignatureIncompatibleReason_incompatibleOutputTypeChange {
    type: "incompatibleOutputTypeChange";
    incompatibleOutputTypeChange: FunctionShapeSignatureIncompatibleOutputTypeChange;
}
type FunctionShapeSignatureIncompatibleReason = FunctionShapeSignatureIncompatibleReason_missingInput | FunctionShapeSignatureIncompatibleReason_unknownRequiredInput | FunctionShapeSignatureIncompatibleReason_incompatibleInputTypeChange | FunctionShapeSignatureIncompatibleReason_incompatibleOutputTypeChange;
/**
 * An input on the unresolved shape is not present on the resolved function.
 */
interface FunctionShapeSignatureMissingInput {
    inputName: FunctionInputName;
}
/**
 * A required input on the resolved function is not present on the unresolved shape.
 */
interface FunctionShapeSignatureUnknownRequiredInput {
    inputName: FunctionInputName;
}
interface FunctionShapeStableId_staticInput {
    type: "staticInput";
    staticInput: FunctionStaticInputStableId;
}
type FunctionShapeStableId = FunctionShapeStableId_staticInput;
/**
 * Encountered a bucket key type variant that is unknown.
 */
interface FunctionShapeUnknownBucketKeyType {
    unknownType: string;
}
/**
 * Encountered a bucket value type variant that is unknown.
 */
interface FunctionShapeUnknownBucketValueType {
    unknownType: string;
}
/**
 * Encountered a data type variant on a shape that is unknown.
 */
interface FunctionShapeUnknownDataType {
    unknownType: string;
}
/**
 * Encountered a geo-shape sub-type variant that is unknown.
 */
interface FunctionShapeUnknownGeoShapeSubType {
    unknownType: string;
}
/**
 * Encountered a logical type reference variant on a shape that is unknown.
 */
interface FunctionShapeUnknownLogicalTypeReference {
    unknownType: string;
}
/**
 * Encountered a marking sub-type variant that is unknown.
 */
interface FunctionShapeUnknownMarkingSubType {
    unknownType: string;
}
/**
 * Encountered a range type variant that is unknown.
 */
interface FunctionShapeUnknownRangeType {
    unknownType: string;
}
/**
 * Encountered a time series value type variant that is unknown.
 */
interface FunctionShapeUnknownTimeSeriesValueType {
    unknownType: string;
}
/**
 * Encountered a vector element type variant that is unknown.
 */
interface FunctionShapeUnknownVectorElementType {
    unknownType: string;
}
/**
 * Encountered a cross-shape reference ID that was not resolvable. This means the user needs to configure an
 * upstream shape first (e.g., an object type input shape).
 */
interface FunctionShapeUnresolvableCrossShapeReference {
    referenceId: BlockShapeId;
}
/**
 * Encountered a data type variant on a shape that is unsupported.
 */
interface FunctionShapeUnsupportedDataType {
    unsupportedType: string;
}
/**
 * Identifier for generating an input shape for a function static input.
 */
interface FunctionStaticInputIdentifier {
    functionRid: FunctionRid;
    functionVersion: FunctionVersion;
    inputName: FunctionInputName;
}
/**
 * Static inputs are uniquely identified by the function the input is on and the name of the input.
 */
interface FunctionStaticInputStableId {
    functionRid: FunctionRid;
    functionVersion: FunctionVersion;
    inputName: FunctionInputName;
}
/**
 * This version is enforced to be a semver string
 */
type FunctionVersion = string;
/**
 * An NPM-compatible semantic version range: https://github.com/npm/node-semver?tab=readme-ov-file#ranges
 * See SemanticVersionRange in function-registry for more specific documentation.
 */
type FunctionVersionRange = string;
interface FunctionVersionsConfiguration_incrementMinor {
    type: "incrementMinor";
    incrementMinor: IncrementMinorFunctionVersionsConfiguration;
}
interface FunctionVersionsConfiguration_preserve {
    type: "preserve";
    preserve: PreserveFunctionVersionsConfiguration;
}
/**
 * Deprecated: Use FunctionsApiStabilityConfiguration instead.
 */
type FunctionVersionsConfiguration = FunctionVersionsConfiguration_incrementMinor | FunctionVersionsConfiguration_preserve;
/**
 * Deprecated: Use FunctionsApiStabilityConfigurationInputIdentifier instead.
 */
interface FunctionVersionsConfigurationInputIdentifier {
}
/**
 * Deprecated: Use FunctionsApiStabilityConfigurationInputShape instead.
 *
 * See ResolvedFunctionVersionsConfigurationInputShape for details.
 */
interface FunctionVersionsConfigurationInputShape {
    about: LocalizedTitleAndDescription;
}
/**
 * Fusion Entity Identifier for generating fusion document shapes
 */
interface FusionDocumentIdentifier {
    rid: string;
}
interface FusionDocumentShape {
    about: LocalizedTitleAndDescription;
}
interface GenerateCompassLocationInputShapesFailure {
    errors: Array<GenerateCompassShapesError>;
}
interface GenerateCompassLocationInputShapesRequest {
    marketplaceRid: MarketplaceRid;
    previousResolvedInputs: Record<BlockShapeId, ResolvedInputShape>;
    resolvedOutputShapes: Record<BlockShapeId, ResolvedOutputShape>;
}
interface GenerateCompassLocationInputShapesResponse {
    locationInputMetadata: Record<BlockShapeId, InputShapeMetadata>;
    locationInputs: Record<BlockShapeId, InputShape>;
    outputToLocationInput: Record<BlockShapeId, InstallLocationBlockShapeId>;
    resolvedLocationInputs: Record<BlockShapeId, ResolvedInputShape>;
}
interface GenerateCompassLocationInputShapesResponseV2_success {
    type: "success";
    success: GenerateCompassLocationInputShapesResponse;
}
interface GenerateCompassLocationInputShapesResponseV2_failure {
    type: "failure";
    failure: GenerateCompassLocationInputShapesFailure;
}
type GenerateCompassLocationInputShapesResponseV2 = GenerateCompassLocationInputShapesResponseV2_success | GenerateCompassLocationInputShapesResponseV2_failure;
interface GenerateCompassShapesError {
    error: MarketplaceSerializableError;
    shapeIds: Array<BlockShapeId>;
}
interface GenerateInputGroupRequest {
    displayMetadata: InputGroupDisplayMetadata;
    inputs: Array<InternalShapeId>;
}
interface GenerateInputShapeRequest {
    metadata?: InputShapeMetadata | null | undefined;
    spec: InputEntityIdentifier;
}
interface GenerateOutputShapeRequest {
    spec: OutputEntityIdentifier;
}
interface GenerateShapesError_serializable {
    type: "serializable";
    serializable: MarketplaceSerializableError;
}
interface GenerateShapesError_actionTypeNotFound {
    type: "actionTypeNotFound";
    actionTypeNotFound: ActionTypeNotFound;
}
interface GenerateShapesError_actionTypeParameterNotFound {
    type: "actionTypeParameterNotFound";
    actionTypeParameterNotFound: ActionTypeParameterNotFound;
}
interface GenerateShapesError_functionNotFound {
    type: "functionNotFound";
    functionNotFound: FunctionNotFound;
}
interface GenerateShapesError_inputGroupWithUnknownReference {
    type: "inputGroupWithUnknownReference";
    inputGroupWithUnknownReference: InputGroupWithUnknownReference;
}
interface GenerateShapesError_linkTypeNotFound {
    type: "linkTypeNotFound";
    linkTypeNotFound: LinkTypeNotFound;
}
interface GenerateShapesError_objectTypeNotFound {
    type: "objectTypeNotFound";
    objectTypeNotFound: ObjectTypeNotFound;
}
interface GenerateShapesError_propertyTypeNotFound {
    type: "propertyTypeNotFound";
    propertyTypeNotFound: PropertyTypeNotFound;
}
interface GenerateShapesError_sharedPropertyTypeNotFound {
    type: "sharedPropertyTypeNotFound";
    sharedPropertyTypeNotFound: SharedPropertyTypeNotFound;
}
interface GenerateShapesError_ontologyDatasourceNotFound {
    type: "ontologyDatasourceNotFound";
    ontologyDatasourceNotFound: OntologyDatasourceNotFound;
}
interface GenerateShapesError_ontologyInterfaceTypeNotFound {
    type: "ontologyInterfaceTypeNotFound";
    ontologyInterfaceTypeNotFound: OntologyInterfaceTypeNotFound;
}
interface GenerateShapesError_interfaceLinkTypeNotFound {
    type: "interfaceLinkTypeNotFound";
    interfaceLinkTypeNotFound: InterfaceLinkTypeNotFound;
}
interface GenerateShapesError_interfacePropertyTypeNotFound {
    type: "interfacePropertyTypeNotFound";
    interfacePropertyTypeNotFound: InterfacePropertyTypeNotFound;
}
interface GenerateShapesError_interfaceActionTypeConstraintNotFound {
    type: "interfaceActionTypeConstraintNotFound";
    interfaceActionTypeConstraintNotFound: InterfaceActionTypeConstraintNotFound;
}
interface GenerateShapesError_objectInstanceNotFound {
    type: "objectInstanceNotFound";
    objectInstanceNotFound: ObjectInstanceNotFound;
}
interface GenerateShapesError_unknownError {
    type: "unknownError";
    unknownError: Void;
}
/**
 * Represents an error encountered during shape generation.
 *
 * Integrations should not add new members to this union. Instead, use the `serializable` variant with a
 * `MarketplaceSerializableError`. By reusing error factories from `MarketplaceErrors` (e.g.
 * `MarketplaceErrors.resourceNotFound`), integrations get rich frontend error rendering for free.
 *
 * Example usage for a resource-not-found error:
 * ```
 * .error(GenerateShapesError.serializable(
 * Exceptions.toSerializableError(MarketplaceErrors.resourceNotFound(rid))))
 * ```
 *
 * Any Conjure error can be wrapped via `Exceptions.toSerializableError`. If you add a new exception,
 * make sure you add a FE renderer in DevOps packaging errors framework.
 */
type GenerateShapesError = GenerateShapesError_serializable | GenerateShapesError_actionTypeNotFound | GenerateShapesError_actionTypeParameterNotFound | GenerateShapesError_functionNotFound | GenerateShapesError_inputGroupWithUnknownReference | GenerateShapesError_linkTypeNotFound | GenerateShapesError_objectTypeNotFound | GenerateShapesError_propertyTypeNotFound | GenerateShapesError_sharedPropertyTypeNotFound | GenerateShapesError_ontologyDatasourceNotFound | GenerateShapesError_ontologyInterfaceTypeNotFound | GenerateShapesError_interfaceLinkTypeNotFound | GenerateShapesError_interfacePropertyTypeNotFound | GenerateShapesError_interfaceActionTypeConstraintNotFound | GenerateShapesError_objectInstanceNotFound | GenerateShapesError_unknownError;
interface GenerateShapesErrorV2 {
    error: GenerateShapesError;
    internalShapeId: InternalShapeId;
}
interface GenerateShapesRequest {
    blockId: BlockId;
    blockType?: BlockType | null | undefined;
    explicitInputs: Record<InternalShapeId, ExplicitInputShapeRequest>;
    inputGroups: Record<InternalShapeId, GenerateInputGroupRequest>;
    inputs: Record<InternalShapeId, GenerateInputShapeRequest>;
    lastVersionId?: BlockVersionId | null | undefined;
    outputs: Record<InternalShapeId, GenerateOutputShapeRequest>;
}
interface GenerateShapesResponse_success {
    type: "success";
    success: GenerateShapesResponseSuccess;
}
interface GenerateShapesResponse_failure {
    type: "failure";
    failure: GenerateShapesResponseFailure;
}
type GenerateShapesResponse = GenerateShapesResponse_success | GenerateShapesResponse_failure;
interface GenerateShapesResponseFailure {
    errors: Array<GenerateShapesError>;
    errorsV2: Array<GenerateShapesErrorV2>;
}
interface GenerateShapesResponseSuccess {
    additionalInputs: Record<BlockShapeId, AdditionalInputShapeResult>;
    additionalOutputs: Record<BlockShapeId, AdditionalOutputShapeResult>;
    explicitInputs: Record<InternalShapeId, ExplicitInputShapeResult>;
    inputGroups: Record<InternalShapeId, InputGroupResult>;
    inputs: Record<InternalShapeId, InputShapeResult>;
    internalShapeIdToBlockShapeId: Record<InternalShapeId, BlockShapeId>;
    internalShapeIdToInputGroupId: Record<InternalShapeId, InputGroupId>;
    outputs: Record<InternalShapeId, OutputShapeResult>;
    outputToLocationInput: Record<BlockShapeId, InternalShapeId>;
}
interface GenerateShapesWithoutBlockRequest {
    inputGroups: Record<InternalShapeId, GenerateInputGroupRequest>;
    inputs: Record<InternalShapeId, GenerateInputShapeRequest>;
    outputs: Record<InternalShapeId, GenerateOutputShapeRequest>;
    previousVersionInputGroups: Record<InternalShapeId, InputGroupId>;
    previousVersionInputs: Record<BlockShapeId, InputShape>;
    previousVersionResolvedInputs: Record<BlockShapeId, ResolvedInputShape>;
    previousVersionResolvedOutputs: Record<BlockShapeId, ResolvedOutputShape>;
}
/**
 * DEPRECATED | Use TypedBlockInstallServiceValidationError instead.
 * This is an untyped error item, which is used by integrating services to surface information to users.
 */
interface GenericBlockInstallServiceValidationError {
    args: Array<ErrorArg>;
    errorMessage: string;
    traceId?: string | null | undefined;
    type: ErrorSeverity;
}
/**
 * A generic error type that can be used to return specific error information to the user.
 */
interface GenericCreateBlockVersionError {
    error: any;
    fallbackMessage: string;
    safeMessageForLogging?: string | null | undefined;
}
/**
 * A generic error type that can be used to return specific error information to the user.
 */
interface GenericCreateBlockVersionErrorV2 {
    errorLabelForLogging: string;
    fallbackMessage: string;
    integrationErrorUnionObject: any;
}
interface GenericDataType_any {
    type: "any";
    any: Void;
}
interface GenericDataType_anyDecimal {
    type: "anyDecimal";
    anyDecimal: Void;
}
interface GenericDataType_oneOf {
    type: "oneOf";
    oneOf: Array<ConcreteDataType>;
}
/**
 * Describes generic types - i.e. multiple possibilities.
 * We can answer the question of whether a particular concrete type satisfies one of these generic types.
 */
type GenericDataType = GenericDataType_any | GenericDataType_anyDecimal | GenericDataType_oneOf;
/**
 * DEPRECATED | Use TypedBlockInstallServiceValidationError instead.
 * This is a weakly typed error item, which is used by integrating services to surface diffs to users. The
 * frontend will perform a diff operation between the two fields, and display the JSON diff between the
 * `actualValue` and `expectedValue`.
 */
interface GenericDiffBlockInstallServiceValidationError {
    actualValue: any;
    args: Array<ErrorArg>;
    errorMessage: string;
    expectedValue: any;
    traceId?: string | null | undefined;
    type: ErrorSeverity;
}
/**
 * GeohashListType specifies that this parameter must be a list of Geohashes.
 */
interface GeohashListType {
}
/**
 * GeohashType specifies that this parameter must be a Geohash.
 */
interface GeohashType {
}
/**
 * GeoshapeListType specifies that this parameter must be a list of Geoshapes.
 */
interface GeoshapeListType {
}
/**
 * GeoshapeType specifies that this parameter must be a Geoshape.
 */
interface GeoshapeType {
}
type GeotimeSeriesIntegrationRid = string;
interface GeotimeSeriesIntegrationShape {
    about: LocalizedTitleAndDescription;
}
/**
 * GeotimeSeriesReferenceListType specifies that this parameter must be a list of GeotimeSeriesReferences.
 * valid allowedParameterValues: ParameterGeotimeSeriesReferenceOrEmpty
 * valid prefill DataValues: None
 */
interface GeotimeSeriesReferenceListType {
}
/**
 * GeotimeSeriesReferenceType specifies that this parameter must be a GeotimeSeriesReference.
 * valid allowedParameterValues: ParameterGeotimeSeriesReferenceOrEmpty
 * valid prefill DataValues: None
 */
interface GeotimeSeriesReferenceType {
}
interface GetBlockSetResponse {
    activeRecalls: Record<RecallId, RecallVersionsAnnouncement>;
    blockSet: BlockSet;
    releaseMetadata: BlockSetVersionReleaseMetadata;
}
interface GetBlockSetShapesResponse {
    inputGroups: BlockSetInputGroups;
    inputShapes: BlockSetInputShapes;
    outputShapes: BlockSetOutputShapes;
    shapeDependencies: Array<BlockSetShapeDependencies>;
}
interface GetBlockSetVersionChangelogResponse {
    changelog?: Changelog | null | undefined;
}
interface GetBlockSetVersionDocumentationResponse {
    attachments: Array<AttachmentMetadata>;
    freeForm?: FreeFormDocumentation | null | undefined;
    freeFormSections?: FreeFormDocumentationSections | null | undefined;
    links?: Links | null | undefined;
    localizedFreeFormSections?: LocalizedFreeFormDocumentationSections | null | undefined;
    thumbnail?: AttachmentMetadata | null | undefined;
}
/**
 * Specs declared in the latest `UpdatePendingBlockSetVersionSpecsRequest` that is currently processing or being
 * processed. As `updatePendingBlockSetVersionSpecs` is asynchronous, this may not be the latest specs that
 * were layed down.
 */
interface GetBlockSetVersionSpecsResponse {
    discoverySpecs: Array<DiscoverySpec>;
    outputSpecs: Array<OutputSpec>;
    settings?: SpecsSettings | null | undefined;
}
interface GetBlockSetVersionStatusResponseV3 {
    status: BlockSetVersionStatusV3;
}
interface GetBlockVersionChangelogResponse {
    changelog: Changelog;
}
interface GetBlockVersionResponse {
    block: Block;
    blockId: BlockId;
    blockVersion: BlockVersion;
    blockVersionId: BlockVersionId;
}
interface GetDownstreamRecommendationsResponse {
    recommendations: Array<ExternalRecommendationV2>;
}
interface GetDraftGroupStatusResponse {
    errors: Array<MarketplaceSerializableError>;
    status: DraftGroupStatus;
}
interface GetGranularBlockSetStatisticsResponse {
    statistics: GranularBlockSetStatistics;
}
interface GetGranularBlockSetStatisticsV3Response {
    statistics: GranularBlockSetStatisticsV3;
}
interface GetInstallableBlockSetVersionResponse {
    about: LocalizedTitleAndDescription;
    additionalRecommendationVariants: Record<BlockSetRecommendationId, BlockSetRecommendationVariant>;
    blocks: Record<BlockSetBlockInstanceId, SingleVersionBlockReference>;
    blockSetInputGroups: Record<InputGroupId, BlockSetInputGroup>;
    blockSetShapes: Record<BlockSetShapeId, BlockSetShape>;
    changelog?: Changelog | null | undefined;
    creationTimestamp: CreationTimestamp;
    defaultInstallationSettings?: DefaultInstallationSettings | null | undefined;
    documentation?: BlockSetDocumentation | null | undefined;
    documentationRepositoryRid: ArtifactsRepositoryRid;
    id: BlockSetId;
    importedAt?: ImportTimestamp | null | undefined;
    installHints?: BlockSetInstallationHints | null | undefined;
    lastKnownVersionBeforeBreak?: BlockSetVersion | null | undefined;
    mappingInfo?: BlockSetShapeMappingInfo | null | undefined;
    marketplaceMetadataVersion?: MarketplaceMetadataVersion | null | undefined;
    mavenCoordinateDependencies: Array<MavenCoordinateDependency>;
    mavenProductId?: MavenProductId | null | undefined;
    releaseMetadata: BlockSetVersionReleaseMetadata;
    tags: Array<BlockSetTag>;
    tagsV2: BlockSetCategorizedTags;
    typedTags: Array<TagRid>;
    version: BlockSetVersion;
    versionId: BlockSetVersionId;
}
interface GetInstallableBlockSetVersionResponseV2 {
    documentation: InstallableBlockSetVersionDocumentation;
    metadata: InstallableBlockSetVersionMetadata;
    shapes: InstallableBlockSetVersionShapes;
}
interface GetInstallableBlockVersionResponse {
    blockDataRepositoryRid: ArtifactsRepositoryRid;
    changelog?: Changelog | null | undefined;
    creationTimestamp: CreationTimestamp;
    id: BlockId;
    internal: BlockInternal;
    version: BlockVersion;
    versionId: BlockVersionId;
}
interface GetInstallAutomationSettingsResponse {
    settings: InstallAutomationSettings;
}
interface GetInstallAutomationStatusResponse {
    status: AutomationStatus;
}
interface GetJobDraftMetadataResponse {
    metadata: JobDraftMetadata;
}
interface GetJobDraftStatusResponse {
    status: JobDraftStatus;
}
interface GetKeysResponse {
    keys: Array<OacSigningKeyEntry>;
}
interface GetLatestBlockVersionResponse {
    block: Block;
    blockId: BlockId;
    blockVersion: BlockVersion;
    blockVersionId: BlockVersionId;
}
interface GetManagedStoresResponse {
    managedStores: Record<MarketplaceRid, ManagedStoreResponseEntry>;
}
interface GetManagedStoresSettingsForOrgResponse {
    managedStores: Record<MarketplaceRid, ManagedStoreSettingsResponseEntry>;
}
interface GetMarketplaceMavenGroupResponse {
    mavenGroup?: MavenGroup | null | undefined;
}
interface GetMarketplaceRidForMavenGroupRequest {
    mavenGroup: MavenGroup;
    namespaceRid: NamespaceRid;
}
interface GetMarketplaceRidForMavenGroupResponse {
    marketplaceRid?: MarketplaceRid | null | undefined;
}
interface GetOwnedBlockVersionResponse {
    block: Block;
    blockDataArtifactsRepositoryRid: ArtifactsRepositoryRid;
    blockId: BlockId;
    blockVersion: BlockVersion;
    blockVersionId: BlockVersionId;
    packagingRequest?: BlockSpecificCreateRequest | null | undefined;
    resolvedInputs: Record<BlockShapeId, ResolvedInputShape>;
    resolvedOutputs: Record<BlockShapeId, ResolvedOutputShape>;
}
interface GetPendingBlockSetShapesResponse {
    inputGroups: BlockSetInputGroups;
    inputShapes: PendingBlockSetInputShapes;
    outputShapes: PendingBlockSetOutputShapes;
    shapeDependencies: Array<BlockSetShapeDependencies>;
}
interface GetPendingBlockSetVersionBlocksResponse {
    blocks: Record<BlockSetBlockInstanceId, SingleVersionBlockReference>;
}
interface GetPendingBlockSetVersionMetadataResponse {
    metadata: PendingBlockSetVersionMetadata;
}
interface GetPendingBlockVersionResponse {
    block: Block;
    blockId: BlockId;
    blockVersion: BlockVersion;
    blockVersionId: BlockVersionId;
    packagingRequest?: BlockSpecificCreateRequest | null | undefined;
    resolvedInputs: Record<BlockShapeId, ResolvedInputShape>;
    resolvedOutputs: Record<BlockShapeId, ResolvedOutputShape>;
}
interface GetPendingRecommendationsResponse {
    recommendationStatus: PendingRecommendationStatus;
    updateId?: UpdateExternalRecsRequestId | null | undefined;
}
interface GetProductGroupResponse {
    productGroup: ProductGroup;
}
/**
 * Response containing the full details of a product group snapshot.
 */
interface GetProductGroupSnapshotResponse {
    snapshot: ProductGroupSnapshot;
}
/**
 * Response containing a specific historical version of a product group. The included definition's
 * members are resolved against the current state of the marketplace — the returned block set
 * versions reflect what the member policies resolve to now, not what they resolved to when this
 * version was authored. For point-in-time resolved state, use snapshots instead.
 */
interface GetProductGroupVersionResponse {
    definition: VersionedProductGroupDefinition;
}
interface GetProductVersionMetadataResponse {
    metadata: ProductVersionMetadata;
}
/**
 * The list of active recall announcements that have been issued for the block set ordered by creation time,
 * newest first. Cancelled recall announcements are not included in this list.
 */
interface GetRecallsForBlockSetResponse {
    activeRecalls: Array<RecallVersionsAnnouncement>;
}
interface GetRecommendationsResponse {
    recommendations: Array<ExternalRecommendationV2>;
}
interface GetRecommendationsResponsePending {
}
interface GetRecommendationsResponseSuccess {
    recommendations: Array<ExternalRecommendationV2>;
}
interface GetRecommendationsResponseV2_pending {
    type: "pending";
    pending: GetRecommendationsResponsePending;
}
interface GetRecommendationsResponseV2_success {
    type: "success";
    success: GetRecommendationsResponseSuccess;
}
/**
 * There is a small delay between block set versions finalizing and the external recommendations finalizing.
 * During this delay, the recommendations will be `GetRecommendationsResponsePending`. Once finalized and the
 * status has changed to `GetRecommendationsResponseSuccess`, it will never go back to
 * `GetRecommendationsResponsePending`.
 */
type GetRecommendationsResponseV2 = GetRecommendationsResponseV2_pending | GetRecommendationsResponseV2_success;
interface GetResolvedJobDraftResponse {
    draft: ResolvedJobDraft;
}
interface GetSigningKeyResponse {
    publicKey: SigningPublicKey;
    publicKeyId: SigningKeyId;
}
interface GetUnresolvedJobDraftResponse {
    draft: UnresolvedJobDraft;
    metadata: JobDraftMetadata;
}
interface GetUserUploadPermissionQuotaResponse {
    isUploadFromMarketplaceEnabled: boolean;
}
type GlobalFunctionApiName = string;
/**
 * The sum of the input shapes of all blocks in the block set.
 */
interface GranularBlockInputShapeSizeLimitCount {
    inputShapeLimit: number;
    inputShapesByType: Record<InputShapeType, number>;
    numberOfInputShapes: number;
    thresholdPercent: number;
}
/**
 * The sum of the input shapes of all blocks in the block set.
 */
interface GranularBlockInputShapeSizeLimitCountV3 {
    inputShapesByType: Record<InputShapeType, number>;
    numberOfInputShapes: number;
}
/**
 * The number of input shapes that need to be provided at installation time for the block set.
 */
interface GranularBlockSetInputShapeSizeLimitCountV3 {
    blockSetInputShapesByType: Record<InputShapeType, number>;
    numberOfBlockSetInputShapes: number;
}
interface GranularBlockSetLimits {
    blockSetInputShapes?: number | null | undefined;
    blockSetOutputShapes?: number | null | undefined;
    blockSetTotalShapes?: number | null | undefined;
    internalBlockInputShapes?: number | null | undefined;
}
interface GranularBlockSetOutputShapeSizeLimitCount {
    numberOfOutputShapes: number;
    outputShapeLimit: number;
    outputShapesByType: Record<OutputShapeType, number>;
    thresholdPercent: number;
}
interface GranularBlockSetOutputShapeSizeLimitCountV3 {
    numberOfOutputShapes: number;
    outputShapesByType: Record<OutputShapeType, number>;
}
interface GranularBlockSetStatistics {
    block?: GranularBlockSizeLimitCount | null | undefined;
    inputShape: GranularBlockInputShapeSizeLimitCount;
    maxThresholdPercent: number;
    outputShape: GranularBlockSetOutputShapeSizeLimitCount;
}
interface GranularBlockSetStatisticsV3 {
    blockInputShapes?: GranularBlockInputShapeSizeLimitCountV3 | null | undefined;
    blockSetInputShapes: GranularBlockSetInputShapeSizeLimitCountV3;
    blockSetOutputShapes: GranularBlockSetOutputShapeSizeLimitCountV3;
    limits: GranularBlockSetLimits;
}
interface GranularBlockSizeLimitCount {
    blockLimit: number;
    blocksByType: Record<BlockType, number>;
    numberOfBlocks: number;
}
interface GranularErrorStatus_inProgressError {
    type: "inProgressError";
    inProgressError: InProgressError;
}
interface GranularErrorStatus_inProgressCancelled {
    type: "inProgressCancelled";
    inProgressCancelled: InProgressCancelled;
}
interface GranularErrorStatus_buildErrored {
    type: "buildErrored";
    buildErrored: BuildError;
}
interface GranularErrorStatus_buildCancelled {
    type: "buildCancelled";
    buildCancelled: BuildCancelled;
}
interface GranularErrorStatus_buildTimedOut {
    type: "buildTimedOut";
    buildTimedOut: BuildTimedOut;
}
/**
 * Comprises of the state the job was in when the error occurred and the type of error.
 */
type GranularErrorStatus = GranularErrorStatus_inProgressError | GranularErrorStatus_inProgressCancelled | GranularErrorStatus_buildErrored | GranularErrorStatus_buildCancelled | GranularErrorStatus_buildTimedOut;
interface GranularInstallPendingStatus_notStarted {
    type: "notStarted";
    notStarted: NotStartedInstallPendingStatus;
}
interface GranularInstallPendingStatus_preallocating {
    type: "preallocating";
    preallocating: PreallocatingInstallPendingStatus;
}
interface GranularInstallPendingStatus_reconciling {
    type: "reconciling";
    reconciling: ReconcilingInstallPendingStatus;
}
interface GranularInstallPendingStatus_pendingBuild {
    type: "pendingBuild";
    pendingBuild: PendingBuildInstallPendingStatus;
}
interface GranularInstallPendingStatus_building {
    type: "building";
    building: BuildingInstallPendingStatus;
}
interface GranularInstallPendingStatus_finished {
    type: "finished";
    finished: FinishedInstallPendingStatus;
}
/**
 * In reality, there are more processing stages in the backend. This is a simplified view of the install
 * lifecycle for the frontend.
 */
type GranularInstallPendingStatus = GranularInstallPendingStatus_notStarted | GranularInstallPendingStatus_preallocating | GranularInstallPendingStatus_reconciling | GranularInstallPendingStatus_pendingBuild | GranularInstallPendingStatus_building | GranularInstallPendingStatus_finished;
interface GranularOutputSpecResult_materializing {
    type: "materializing";
    materializing: Void;
}
interface GranularOutputSpecResult_dataUploading {
    type: "dataUploading";
    dataUploading: SuccessGranularOutputSpecResult;
}
interface GranularOutputSpecResult_success {
    type: "success";
    success: SuccessGranularOutputSpecResult;
}
interface GranularOutputSpecResult_error {
    type: "error";
    error: ErrorGranularOutputSpecResult;
}
interface GranularOutputSpecResult_unsupported {
    type: "unsupported";
    unsupported: Void;
}
interface GranularOutputSpecResult_ignored {
    type: "ignored";
    ignored: Void;
}
type GranularOutputSpecResult = GranularOutputSpecResult_materializing | GranularOutputSpecResult_dataUploading | GranularOutputSpecResult_success | GranularOutputSpecResult_error | GranularOutputSpecResult_unsupported | GranularOutputSpecResult_ignored;
interface GroupAlreadyUsedFailure {
    conflictingMarketplaceRid: MarketplaceRid;
}
/**
 * Filters pending block set versions by their draft group membership status.
 */
type GroupFilter = "ALL" | "NOT_IN_GROUP" | "IN_GROUP";
type GroupId = string;
interface GroupMalformedFailure {
}
interface GroupReference {
    blockInstance: BlockSetBlockInstanceId;
    groupId: InputGroupId;
}
/**
 * If included in a Cipher License, the user has the ability to perform Cipher operations without any limit and
 * without needing justification in high trust environments. This is the permit to use for using Cipher in Apps
 * like Pipelines Builder.
 */
interface HighTrustRequestPermit {
    requestType: RequestType;
}
interface IdleBlockSetVersionStatus {
    error?: BlockSetVersionErrorRecovery | null | undefined;
    hasPendingOperations?: boolean | null | undefined;
    latestProcessedUpdateId?: UpdatePendingBlockSetVersionSpecsRequestId | null | undefined;
    outputSpecResults: Array<OutputSpecResult>;
    validationErrors: Array<BlockSetVersionValidationError>;
}
/**
 * There is nothing for the automation to do. The installation is on the latest product version.
 */
interface IdleStatus {
}
interface IdleStatusV3 {
    hasErrors: boolean;
    hasWarnings: boolean;
}
interface IgnoreConfig {
    ignoreRidPatternsAndDescendants: Array<RidFilter>;
}
interface ImageryDecodeFormat_tiff {
    type: "tiff";
    tiff: TiffFormat;
}
interface ImageryDecodeFormat_nitf {
    type: "nitf";
    nitf: NitfFormat;
}
interface ImageryDecodeFormat_jp2k {
    type: "jp2k";
    jp2k: Jpeg2000Format;
}
interface ImageryDecodeFormat_jpg {
    type: "jpg";
    jpg: JpgFormat;
}
interface ImageryDecodeFormat_png {
    type: "png";
    png: PngFormat;
}
interface ImageryDecodeFormat_bmp {
    type: "bmp";
    bmp: BmpFormat;
}
interface ImageryDecodeFormat_webp {
    type: "webp";
    webp: WebpFormat;
}
type ImageryDecodeFormat = ImageryDecodeFormat_tiff | ImageryDecodeFormat_nitf | ImageryDecodeFormat_jp2k | ImageryDecodeFormat_jpg | ImageryDecodeFormat_png | ImageryDecodeFormat_bmp | ImageryDecodeFormat_webp;
interface ImagerySchema {
    format: ImageryDecodeFormat;
}
interface ImportBlockSetResponse {
    blockSetId: BlockSetId;
    blockSetVersionId: BlockSetVersionId;
    maybeSigningKeyId?: SigningKeyId | null | undefined;
}
type ImportTimestamp = string;
interface IncludeFunctionsConfig {
    fromCodeRepositories: boolean;
    fromLogicFiles: boolean;
}
interface IncludeHealthCheckConfig {
    fromDatasets: boolean;
}
type IncludeModelContent = "INCLUDED" | "EXCLUDED";
interface IncludeObjectViewsConfig {
    fromObjectTypes: boolean;
}
interface IncludeOntologyEntitiesConfig {
    fromOntologyPackages: boolean;
}
interface IncludeSchedulesConfig {
    fromTargets: boolean;
    includeDisabled: boolean;
}
interface IncompatibleContractSemverError {
    actual: FunctionContractVersion;
    allowedMax: FunctionContractVersion;
    allowedMin: FunctionContractVersion;
    contractRid: FunctionContractRid;
}
/**
 * A downstream product's external recommendation to an upstream product specifies a
 * version compatibility range, but the upstream product's resolved version falls
 * outside that range. The downstream product needs repackaging against the upstream's
 * current version.
 */
interface IncompatibleExternalRecommendationVersionRange {
    compatibleVersionRange: BlockSetVersionRange;
    downstream: ProductGroupMemberRid;
    upstream: ProductGroupMemberRid;
    upstreamResolvedVersion: SemverVersion;
}
interface IncompatibleLinkedProduct {
    compatibleVersionRange: BlockSetVersionRange;
    upstreamBlockSet: BlockSetId;
    upstreamBlockSetInstallation: BlockSetReference;
    upstreamBlockSetVersion: SemverVersion;
}
interface IncompatibleSemverError {
    actual: string;
    allowedMax: string;
    allowedMin: string;
}
/**
 * Deprecated: Use DeduplicateFunctionsApiStabilityConfiguration instead.
 *
 * This configuration indicates that on installation or upgrade of a Marketplace package, the version of a
 * function that is chosen during block pre-allocation is determined by incrementing the minor version of the
 * existing function's latest version.
 *
 * For example, if the existing function has latest version "1.2.3", pre-allocation will return version "1.3.0".
 *
 * This configuration should be avoided, but exists for backward compatibility with old behavior.
 */
interface IncrementMinorFunctionVersionsConfiguration {
}
interface IndexableEntityIds {
    indexableEntityRid: IndexableEntityRid;
}
/**
 * The resource identifier for anything that can be indexed into the OSv2 ontology. (Currently this represents
 * object types and many-to-many link types.)
 */
type IndexableEntityRid = string;
/**
 * An indexing pipeline was created for an ontology entity as part of the install, but this index failed.
 */
interface IndexFailure {
    indexableEntityRids: Record<OutputBlockSetShapeId, IndexableEntityRid>;
}
/**
 * An indexing pipeline was created for an ontology entity as part of the install, but this index did not succeed
 * within the timeout period defined by Marketplace for an installation build and index.
 */
interface IndexTimeout {
    indexableEntityRids: Record<OutputBlockSetShapeId, IndexableEntityRid>;
}
/**
 * Two inputs are indistinguishable if:
 *
 * - They have the same title
 * - They are from the same backing block
 *
 * For two inputs where both of the above are true, there will be no way for installers to distinguish them from
 * each other, making it likely that they will map their inputs incorrectly.
 *
 * To fix this, users will need to rename one of the inputs.
 */
interface IndistinguishableInputShapesError {
    block: BlockSetBlockInstanceId;
    blockType: BlockType;
    shapeIds: Array<InputBlockSetShapeId>;
    shapeType: InputShapeType;
    title: string;
}
interface InferredFolderStructureSettings_enabled {
    type: "enabled";
    enabled: Void;
}
interface InferredFolderStructureSettings_disabled {
    type: "disabled";
    disabled: Void;
}
/**
 * Inferred folder structure takes the block set output specs and infers the folder structure that resources
 * should be organised within in the installed project and includes them as resources in the packaged block set.
 * We infer the folders by finding the lowest common ancestor of the Compass resource output specs. This LCA
 * mirrors the installation project as the root, therefore we include all folders under this LCA in the block
 * set, excluding the LCA itself.
 *
 * If disabled, we do not do any automatic inferrence.
 *
 * In either case, any folders included as output specs will be treated like any other output specs and
 * materialize as normal.
 */
type InferredFolderStructureSettings = InferredFolderStructureSettings_enabled | InferredFolderStructureSettings_disabled;
interface InitializingStatusV3 {
}
/**
 * The property has no associated inline ActionType whereas the shape definition requires one.
 */
interface InlineActionTypeMissing {
    expected: ActionTypeReference;
}
interface InProgressCancelled {
}
interface InProgressError {
}
interface InputBlockSetMappingInfo {
    backingShapes: Array<ShapeReference>;
    isOptional: boolean;
    metadata?: InputBlockSetShapeMetadata | null | undefined;
    resolvedShape?: ResolvedBlockSetInputShape | null | undefined;
    shape: BlockSetInputShape;
}
interface InputBlockSetShapeAboutMetadata {
    original: LocalizedTitleAndDescription;
    override?: LocalizedTitleAndDescriptionOverride | null | undefined;
}
type InputBlockSetShapeId = BlockSetShapeId;
interface InputBlockSetShapeMetadata {
    about: InputBlockSetShapeAboutMetadata;
    presets?: InputPreset | null | undefined;
    visibility?: BlockSetShapeVisibility | null | undefined;
}
interface InputDependencyCycle {
    blocksInCycle: Array<BlockIdAndType>;
}
/**
 * The given input was downstream of the given outputs in the job spec graph. This is not allowed, because it
 * could lead to cycles when integrations put job specs during installation.
 */
interface InputDownstreamOfOutputsInJobSpecGraph {
    input: string;
    outputs: Array<string>;
}
type InputEditsSupport = "ANY" | "REQUIRED";
interface InputEntityIdentifier_action {
    type: "action";
    action: ActionTypeIdentifier;
}
interface InputEntityIdentifier_actionParameter {
    type: "actionParameter";
    actionParameter: ActionTypeParameterIdentifier;
}
interface InputEntityIdentifier_aipAgent {
    type: "aipAgent";
    aipAgent: AipAgentIdentifier;
}
interface InputEntityIdentifier_allowOntologySchemaMigrations {
    type: "allowOntologySchemaMigrations";
    allowOntologySchemaMigrations: LegacyNotImplementedIdentifier;
}
interface InputEntityIdentifier_artifactsRepository {
    type: "artifactsRepository";
    artifactsRepository: ArtifactsRepositoryIdentifier;
}
interface InputEntityIdentifier_authoringLibrary {
    type: "authoringLibrary";
    authoringLibrary: AuthoringLibraryIdentifier;
}
interface InputEntityIdentifier_authoringRepository {
    type: "authoringRepository";
    authoringRepository: AuthoringRepositoryIdentifier;
}
interface InputEntityIdentifier_automation {
    type: "automation";
    automation: AutomationIdentifier;
}
interface InputEntityIdentifier_autopilotWorkbench {
    type: "autopilotWorkbench";
    autopilotWorkbench: AutopilotWorkbenchIdentifier;
}
interface InputEntityIdentifier_blobster {
    type: "blobster";
    blobster: BlobsterInputIdentifier;
}
interface InputEntityIdentifier_carbonWorkspace {
    type: "carbonWorkspace";
    carbonWorkspace: CarbonWorkspaceIdentifier;
}
interface InputEntityIdentifier_cipherChannel {
    type: "cipherChannel";
    cipherChannel: CipherChannelEntityIdentifier;
}
interface InputEntityIdentifier_cipherLicense {
    type: "cipherLicense";
    cipherLicense: CipherLicenseInputIdentifier;
}
interface InputEntityIdentifier_cipherLicenseV2 {
    type: "cipherLicenseV2";
    cipherLicenseV2: CipherLicenseEntityIdentifier;
}
interface InputEntityIdentifier_codeWorkspace {
    type: "codeWorkspace";
    codeWorkspace: CodeWorkspaceIdentifier;
}
interface InputEntityIdentifier_codeWorkspaceLicense {
    type: "codeWorkspaceLicense";
    codeWorkspaceLicense: CodeWorkspaceLicenseIdentifier;
}
interface InputEntityIdentifier_compassResource {
    type: "compassResource";
    compassResource: CompassResourceInputIdentifier;
}
interface InputEntityIdentifier_contourAnalysis {
    type: "contourAnalysis";
    contourAnalysis: ContourAnalysisEntityIdentifier;
}
interface InputEntityIdentifier_contourRef {
    type: "contourRef";
    contourRef: ContourRefEntityIdentifier;
}
interface InputEntityIdentifier_dataHealthCheck {
    type: "dataHealthCheck";
    dataHealthCheck: DataHealthCheckIdentifier;
}
interface InputEntityIdentifier_dataHealthCheckGroup {
    type: "dataHealthCheckGroup";
    dataHealthCheckGroup: DataHealthCheckGroupIdentifier;
}
interface InputEntityIdentifier_datasourceColumn {
    type: "datasourceColumn";
    datasourceColumn: DatasourceColumnIdentifier;
}
interface InputEntityIdentifier_deployedApp {
    type: "deployedApp";
    deployedApp: DeployedAppIdentifier;
}
interface InputEntityIdentifier_eddieParameter {
    type: "eddieParameter";
    eddieParameter: LegacyNotImplementedIdentifier;
}
interface InputEntityIdentifier_eddieParameterV2 {
    type: "eddieParameterV2";
    eddieParameterV2: LegacyNotImplementedIdentifier;
}
interface InputEntityIdentifier_eddiePipeline {
    type: "eddiePipeline";
    eddiePipeline: EddiePipelineIdentifier;
}
interface InputEntityIdentifier_eddieReplayOption {
    type: "eddieReplayOption";
    eddieReplayOption: LegacyNotImplementedIdentifier;
}
interface InputEntityIdentifier_eddieGeotimeConfiguration {
    type: "eddieGeotimeConfiguration";
    eddieGeotimeConfiguration: EddieGeotimeInputIdentifier;
}
interface InputEntityIdentifier_eddieEdgeParameter {
    type: "eddieEdgeParameter";
    eddieEdgeParameter: EddieEdgeParameterInputIdentifier;
}
interface InputEntityIdentifier_edgePipelineMagritteSource {
    type: "edgePipelineMagritteSource";
    edgePipelineMagritteSource: EdgePipelineMagritteSourceInputIdentifier;
}
interface InputEntityIdentifier_evaluationSuite {
    type: "evaluationSuite";
    evaluationSuite: EvaluationSuiteIdentifier;
}
interface InputEntityIdentifier_filesDatasource {
    type: "filesDatasource";
    filesDatasource: FilesDatasourceInputIdentifier;
}
interface InputEntityIdentifier_flinkProfile {
    type: "flinkProfile";
    flinkProfile: FlinkProfileIdentifier;
}
interface InputEntityIdentifier_function {
    type: "function";
    function: FunctionInputIdentifier;
}
interface InputEntityIdentifier_functionContract {
    type: "functionContract";
    functionContract: FunctionContractIdentifier;
}
interface InputEntityIdentifier_functionVersionsConfiguration {
    type: "functionVersionsConfiguration";
    functionVersionsConfiguration: FunctionVersionsConfigurationInputIdentifier;
}
interface InputEntityIdentifier_functionsApiStabilityConfiguration {
    type: "functionsApiStabilityConfiguration";
    functionsApiStabilityConfiguration: FunctionsApiStabilityConfigurationInputIdentifier;
}
interface InputEntityIdentifier_fusionDocument {
    type: "fusionDocument";
    fusionDocument: FusionDocumentIdentifier;
}
interface InputEntityIdentifier_geotimeSeriesIntegration {
    type: "geotimeSeriesIntegration";
    geotimeSeriesIntegration: GeotimeSeriesIntegrationRid;
}
interface InputEntityIdentifier_interfaceType {
    type: "interfaceType";
    interfaceType: InterfaceTypeIdentifier;
}
interface InputEntityIdentifier_interfaceLinkType {
    type: "interfaceLinkType";
    interfaceLinkType: InterfaceLinkTypeIdentifier;
}
interface InputEntityIdentifier_interfacePropertyType {
    type: "interfacePropertyType";
    interfacePropertyType: InterfacePropertyTypeIdentifier;
}
interface InputEntityIdentifier_interfaceActionTypeConstraint {
    type: "interfaceActionTypeConstraint";
    interfaceActionTypeConstraint: InterfaceActionTypeConstraintIdentifier;
}
interface InputEntityIdentifier_interfaceParameterConstraint {
    type: "interfaceParameterConstraint";
    interfaceParameterConstraint: InterfaceParameterConstraintIdentifier;
}
interface InputEntityIdentifier_installPrefix {
    type: "installPrefix";
    installPrefix: LegacyNotImplementedIdentifier;
}
interface InputEntityIdentifier_languageModel {
    type: "languageModel";
    languageModel: LanguageModelIdentifier;
}
interface InputEntityIdentifier_link {
    type: "link";
    link: InputLinkTypeIdentifier;
}
interface InputEntityIdentifier_logic {
    type: "logic";
    logic: LogicIdentifier;
}
interface InputEntityIdentifier_logicFunction {
    type: "logicFunction";
    logicFunction: LogicFunctionIdentifier;
}
interface InputEntityIdentifier_machinery {
    type: "machinery";
    machinery: MachineryProcessIdentifier;
}
interface InputEntityIdentifier_magritteConnection {
    type: "magritteConnection";
    magritteConnection: MagritteConnectionIdentifier;
}
interface InputEntityIdentifier_magritteExport {
    type: "magritteExport";
    magritteExport: MagritteExportIdentifier;
}
interface InputEntityIdentifier_magritteSource {
    type: "magritteSource";
    magritteSource: MagritteSourceIdentifier;
}
interface InputEntityIdentifier_magritteSourceConfigOverrides {
    type: "magritteSourceConfigOverrides";
    magritteSourceConfigOverrides: MagritteSourceConfigOverridesInputIdentifier;
}
interface InputEntityIdentifier_magritteStreamingExtractConfigOverrides {
    type: "magritteStreamingExtractConfigOverrides";
    magritteStreamingExtractConfigOverrides: MagritteStreamingExtractConfigOverridesInputIdentifier;
}
interface InputEntityIdentifier_markings {
    type: "markings";
    markings: MarkingsIdentifier;
}
interface InputEntityIdentifier_modelStudio {
    type: "modelStudio";
    modelStudio: ModelStudioIdentifier;
}
interface InputEntityIdentifier_model {
    type: "model";
    model: ModelInputIdentifier;
}
interface InputEntityIdentifier_monitorView {
    type: "monitorView";
    monitorView: MonitorViewIdentifier;
}
interface InputEntityIdentifier_monocleGraph {
    type: "monocleGraph";
    monocleGraph: MonocleGraphIdentifier;
}
interface InputEntityIdentifier_multipassUserAttribute {
    type: "multipassUserAttribute";
    multipassUserAttribute: MultipassUserAttributeName;
}
interface InputEntityIdentifier_multipassGroup {
    type: "multipassGroup";
    multipassGroup: MultipassGroupId;
}
interface InputEntityIdentifier_namedCredential {
    type: "namedCredential";
    namedCredential: NamedCredentialIdentifier;
}
interface InputEntityIdentifier_networkEgressPolicy {
    type: "networkEgressPolicy";
    networkEgressPolicy: NetworkEgressPolicyIdentifier;
}
interface InputEntityIdentifier_notepadDocument {
    type: "notepadDocument";
    notepadDocument: NotepadPartialResolvedShape;
}
interface InputEntityIdentifier_notepadTemplate {
    type: "notepadTemplate";
    notepadTemplate: NotepadTemplateIdentifier;
}
interface InputEntityIdentifier_notepadTemplateParameter {
    type: "notepadTemplateParameter";
    notepadTemplateParameter: NotepadTemplateParameterIdentifier;
}
interface InputEntityIdentifier_objectInstance {
    type: "objectInstance";
    objectInstance: ObjectInstanceIdentifier;
}
interface InputEntityIdentifier_objectSet {
    type: "objectSet";
    objectSet: ObjectSetIdentifier;
}
interface InputEntityIdentifier_objectType {
    type: "objectType";
    objectType: InputObjectTypeIdentifier;
}
interface InputEntityIdentifier_objectView {
    type: "objectView";
    objectView: LegacyNotImplementedIdentifier;
}
interface InputEntityIdentifier_objectViewTab {
    type: "objectViewTab";
    objectViewTab: LegacyNotImplementedIdentifier;
}
interface InputEntityIdentifier_ontologyDatasource {
    type: "ontologyDatasource";
    ontologyDatasource: OntologyDatasourceIdentifier;
}
interface InputEntityIdentifier_ontologySdk {
    type: "ontologySdk";
    ontologySdk: OntologySdkEntityIdentifier;
}
interface InputEntityIdentifier_parameter {
    type: "parameter";
    parameter: ParameterPartialResolvedShape;
}
interface InputEntityIdentifier_peerProducerProfile {
    type: "peerProducerProfile";
    peerProducerProfile: PeerProducerProfileIdentifier;
}
interface InputEntityIdentifier_peerProfile {
    type: "peerProfile";
    peerProfile: PeerProfileIdentifier;
}
interface InputEntityIdentifier_peerProfileRemoteStrategy {
    type: "peerProfileRemoteStrategy";
    peerProfileRemoteStrategy: PeerProfileRemoteStrategyIdentifier;
}
interface InputEntityIdentifier_property {
    type: "property";
    property: PropertyIdentifier;
}
interface InputEntityIdentifier_quiverDashboard {
    type: "quiverDashboard";
    quiverDashboard: QuiverDashboardIdentifier;
}
interface InputEntityIdentifier_schedule {
    type: "schedule";
    schedule: ScheduleIdentifier;
}
interface InputEntityIdentifier_sharedPropertyType {
    type: "sharedPropertyType";
    sharedPropertyType: SharedPropertyTypeIdentifier;
}
interface InputEntityIdentifier_slateApplication {
    type: "slateApplication";
    slateApplication: SlateApplicationIdentifier;
}
interface InputEntityIdentifier_storedProcedure {
    type: "storedProcedure";
    storedProcedure: StoredProcedureEntityIdentifier;
}
interface InputEntityIdentifier_solutionDesign {
    type: "solutionDesign";
    solutionDesign: SolutionDesignIdentifier;
}
interface InputEntityIdentifier_sparkProfile {
    type: "sparkProfile";
    sparkProfile: SparkProfileIdentifier;
}
interface InputEntityIdentifier_tabularDatasource {
    type: "tabularDatasource";
    tabularDatasource: TabularDatasourceInputIdentifier;
}
interface InputEntityIdentifier_taurusWorkflow {
    type: "taurusWorkflow";
    taurusWorkflow: TaurusWorkflowIdentifier;
}
interface InputEntityIdentifier_thirdPartyApplication {
    type: "thirdPartyApplication";
    thirdPartyApplication: ThirdPartyApplicationEntityIdentifier;
}
interface InputEntityIdentifier_timeSeriesSync {
    type: "timeSeriesSync";
    timeSeriesSync: TimeSeriesSyncRid;
}
interface InputEntityIdentifier_valueType {
    type: "valueType";
    valueType: VersionedValueTypeIdentifier;
}
interface InputEntityIdentifier_vectorWorkbook {
    type: "vectorWorkbook";
    vectorWorkbook: VectorWorkbookIdentifier;
}
interface InputEntityIdentifier_versionedObjectSet {
    type: "versionedObjectSet";
    versionedObjectSet: VersionedObjectSetEntityIdentifier;
}
interface InputEntityIdentifier_vertexTemplate {
    type: "vertexTemplate";
    vertexTemplate: VertexEntityIdentifier;
}
interface InputEntityIdentifier_vortexTemplate {
    type: "vortexTemplate";
    vortexTemplate: VortexEntityIdentifier;
}
interface InputEntityIdentifier_walkthrough {
    type: "walkthrough";
    walkthrough: WalkthroughEntityIdentifier;
}
interface InputEntityIdentifier_webhook {
    type: "webhook";
    webhook: WebhookEntityIdentifier;
}
interface InputEntityIdentifier_widget {
    type: "widget";
    widget: WidgetIdentifier;
}
interface InputEntityIdentifier_widgetSet {
    type: "widgetSet";
    widgetSet: WidgetSetIdentifier;
}
interface InputEntityIdentifier_workbenchTemplate {
    type: "workbenchTemplate";
    workbenchTemplate: WorkbenchTemplateIdentifier;
}
interface InputEntityIdentifier_workflowBuilderGraph {
    type: "workflowBuilderGraph";
    workflowBuilderGraph: WorkflowBuilderGraphIdentifier;
}
interface InputEntityIdentifier_workflowGraph {
    type: "workflowGraph";
    workflowGraph: WorkflowGraphIdentifier;
}
interface InputEntityIdentifier_sqlWorksheet {
    type: "sqlWorksheet";
    sqlWorksheet: SqlWorksheetEntityIdentifier;
}
interface InputEntityIdentifier_workshop {
    type: "workshop";
    workshop: WorkshopIdentifier;
}
interface InputEntityIdentifier_workshopSaveLocation {
    type: "workshopSaveLocation";
    workshopSaveLocation: WorkshopApplicationSaveLocationPartialResolvedShape;
}
/**
 * Entity Identifiers are the minimum needed to identify a resource and any constraints. This can include multiple
 * options to identify the resource eg. ObjectTypeId OR ObjectTypeRid can identify an object type in a
 * consuming service.
 */
type InputEntityIdentifier = InputEntityIdentifier_action | InputEntityIdentifier_actionParameter | InputEntityIdentifier_aipAgent | InputEntityIdentifier_allowOntologySchemaMigrations | InputEntityIdentifier_artifactsRepository | InputEntityIdentifier_authoringLibrary | InputEntityIdentifier_authoringRepository | InputEntityIdentifier_automation | InputEntityIdentifier_autopilotWorkbench | InputEntityIdentifier_blobster | InputEntityIdentifier_carbonWorkspace | InputEntityIdentifier_cipherChannel | InputEntityIdentifier_cipherLicense | InputEntityIdentifier_cipherLicenseV2 | InputEntityIdentifier_codeWorkspace | InputEntityIdentifier_codeWorkspaceLicense | InputEntityIdentifier_compassResource | InputEntityIdentifier_contourAnalysis | InputEntityIdentifier_contourRef | InputEntityIdentifier_dataHealthCheck | InputEntityIdentifier_dataHealthCheckGroup | InputEntityIdentifier_datasourceColumn | InputEntityIdentifier_deployedApp | InputEntityIdentifier_eddieParameter | InputEntityIdentifier_eddieParameterV2 | InputEntityIdentifier_eddiePipeline | InputEntityIdentifier_eddieReplayOption | InputEntityIdentifier_eddieGeotimeConfiguration | InputEntityIdentifier_eddieEdgeParameter | InputEntityIdentifier_edgePipelineMagritteSource | InputEntityIdentifier_evaluationSuite | InputEntityIdentifier_filesDatasource | InputEntityIdentifier_flinkProfile | InputEntityIdentifier_function | InputEntityIdentifier_functionContract | InputEntityIdentifier_functionVersionsConfiguration | InputEntityIdentifier_functionsApiStabilityConfiguration | InputEntityIdentifier_fusionDocument | InputEntityIdentifier_geotimeSeriesIntegration | InputEntityIdentifier_interfaceType | InputEntityIdentifier_interfaceLinkType | InputEntityIdentifier_interfacePropertyType | InputEntityIdentifier_interfaceActionTypeConstraint | InputEntityIdentifier_interfaceParameterConstraint | InputEntityIdentifier_installPrefix | InputEntityIdentifier_languageModel | InputEntityIdentifier_link | InputEntityIdentifier_logic | InputEntityIdentifier_logicFunction | InputEntityIdentifier_machinery | InputEntityIdentifier_magritteConnection | InputEntityIdentifier_magritteExport | InputEntityIdentifier_magritteSource | InputEntityIdentifier_magritteSourceConfigOverrides | InputEntityIdentifier_magritteStreamingExtractConfigOverrides | InputEntityIdentifier_markings | InputEntityIdentifier_modelStudio | InputEntityIdentifier_model | InputEntityIdentifier_monitorView | InputEntityIdentifier_monocleGraph | InputEntityIdentifier_multipassUserAttribute | InputEntityIdentifier_multipassGroup | InputEntityIdentifier_namedCredential | InputEntityIdentifier_networkEgressPolicy | InputEntityIdentifier_notepadDocument | InputEntityIdentifier_notepadTemplate | InputEntityIdentifier_notepadTemplateParameter | InputEntityIdentifier_objectInstance | InputEntityIdentifier_objectSet | InputEntityIdentifier_objectType | InputEntityIdentifier_objectView | InputEntityIdentifier_objectViewTab | InputEntityIdentifier_ontologyDatasource | InputEntityIdentifier_ontologySdk | InputEntityIdentifier_parameter | InputEntityIdentifier_peerProducerProfile | InputEntityIdentifier_peerProfile | InputEntityIdentifier_peerProfileRemoteStrategy | InputEntityIdentifier_property | InputEntityIdentifier_quiverDashboard | InputEntityIdentifier_schedule | InputEntityIdentifier_sharedPropertyType | InputEntityIdentifier_slateApplication | InputEntityIdentifier_storedProcedure | InputEntityIdentifier_solutionDesign | InputEntityIdentifier_sparkProfile | InputEntityIdentifier_tabularDatasource | InputEntityIdentifier_taurusWorkflow | InputEntityIdentifier_thirdPartyApplication | InputEntityIdentifier_timeSeriesSync | InputEntityIdentifier_valueType | InputEntityIdentifier_vectorWorkbook | InputEntityIdentifier_versionedObjectSet | InputEntityIdentifier_vertexTemplate | InputEntityIdentifier_vortexTemplate | InputEntityIdentifier_walkthrough | InputEntityIdentifier_webhook | InputEntityIdentifier_widget | InputEntityIdentifier_widgetSet | InputEntityIdentifier_workbenchTemplate | InputEntityIdentifier_workflowBuilderGraph | InputEntityIdentifier_workflowGraph | InputEntityIdentifier_sqlWorksheet | InputEntityIdentifier_workshop | InputEntityIdentifier_workshopSaveLocation;
/**
 * Group inputs that need to be present together during installation.
 *
 * A group may represent a feature or some other logical grouping where there referenced input shapes
 * are necessary for it to function but its existence is optional to the object as a whole being packaged.
 * For each group present, users will have the choice to opt in/out during installation (see ResolvedInputGroup).
 *
 * For groups that are opted-in (ResolvedInputGroup.enabled=true) the inputs referenced by it will become
 * required regardless if they are defined as optional using `inputMetadata`.
 * If an input is present in multiple groups, any of them being enabled will make the input required.
 */
interface InputGroup {
    displayMetadata: InputGroupDisplayMetadata;
    inputReferences: Array<BlockShapeId>;
}
interface InputGroupBlockSetMappingInfo {
    backingGroups: Array<GroupReference>;
    dependents: Array<OutputBlockSetShapeId>;
    displayMetadata: InputGroupDisplayMetadata;
    inputReferences: Array<InputBlockSetShapeId>;
}
interface InputGroupDisplayMetadata {
    about: LocalizedTitleAndDescription;
}
interface InputGroupDoesNotExistInBlockError {
    inputGroupId: InputGroupId;
}
type InputGroupId = string;
interface InputGroupResult {
    group: InputGroup;
    inputGroupId: InputGroupId;
    internalShapeId: InternalShapeId;
}
interface InputGroupValidationErrors_inputGroupDoesNotExistInBlock {
    type: "inputGroupDoesNotExistInBlock";
    inputGroupDoesNotExistInBlock: InputGroupDoesNotExistInBlockError;
}
type InputGroupValidationErrors = InputGroupValidationErrors_inputGroupDoesNotExistInBlock;
interface InputGroupWithUnknownReference {
    internalShapeId: InternalShapeId;
}
interface InputLinkTypeIdentifier {
    editsSupport: InputEditsSupport;
    identifier: LinkTypeIdentifier;
    objectsBackendVersion: InputObjectBackendVersion;
}
type InputObjectBackendVersion = "V1_OR_V2" | "V2";
interface InputObjectTypeIdentifier {
    editsSupport: InputEditsSupport;
    identifier: ObjectTypeIdentifier;
    objectsBackendVersion: InputObjectBackendVersion;
}
interface InputPreset {
    enforcement?: PresetEnforcement | null | undefined;
    exportCompatibility: ExportCompatibility;
    isDefault?: boolean | null | undefined;
    value: PresetValue;
}
interface InputPresetResolutionResult {
    defaultResolutionResult?: ResolvedShapeResolutionResultUnion | null | undefined;
    presetEnforcement: PresetEnforcement;
    resolvedValue: ResolvedPresetValue;
}
/**
 * Pairing of an input of one block set to the output of another
 */
interface InputRecommendationV2 {
    fulfilledBy: OutputBlockSetShapeId;
    input: InputBlockSetShapeId;
}
interface InputShape_action {
    type: "action";
    action: ActionTypeShape;
}
interface InputShape_actionParameter {
    type: "actionParameter";
    actionParameter: ActionTypeParameterShape;
}
interface InputShape_allowOntologySchemaMigrations {
    type: "allowOntologySchemaMigrations";
    allowOntologySchemaMigrations: AllowOntologySchemaMigrationsShape;
}
interface InputShape_aipAgent {
    type: "aipAgent";
    aipAgent: AipAgentShape;
}
interface InputShape_artifactsRepository {
    type: "artifactsRepository";
    artifactsRepository: ArtifactsRepositoryShape;
}
interface InputShape_authoringLibrary {
    type: "authoringLibrary";
    authoringLibrary: AuthoringLibraryShape;
}
interface InputShape_authoringRepository {
    type: "authoringRepository";
    authoringRepository: AuthoringRepositoryShape;
}
interface InputShape_automation {
    type: "automation";
    automation: AutomationShape;
}
interface InputShape_autopilotWorkbench {
    type: "autopilotWorkbench";
    autopilotWorkbench: AutopilotWorkbenchShape;
}
interface InputShape_carbonWorkspace {
    type: "carbonWorkspace";
    carbonWorkspace: CarbonWorkspaceInputShape;
}
interface InputShape_cipherLicense {
    type: "cipherLicense";
    cipherLicense: CipherLicenseInputShape;
}
interface InputShape_cipherLicenseV2 {
    type: "cipherLicenseV2";
    cipherLicenseV2: CipherLicenseInputShapeV2;
}
interface InputShape_blobsterResource {
    type: "blobsterResource";
    blobsterResource: BlobsterResourceInputShape;
}
interface InputShape_cipherChannel {
    type: "cipherChannel";
    cipherChannel: CipherChannelInputShape;
}
interface InputShape_codeWorkspace {
    type: "codeWorkspace";
    codeWorkspace: CodeWorkspaceInputShape;
}
interface InputShape_codeWorkspaceLicense {
    type: "codeWorkspaceLicense";
    codeWorkspaceLicense: CodeWorkspaceLicenseInputShape;
}
interface InputShape_compassResource {
    type: "compassResource";
    compassResource: CompassResourceInputShape;
}
interface InputShape_contourAnalysis {
    type: "contourAnalysis";
    contourAnalysis: ContourAnalysisShape;
}
interface InputShape_contourRef {
    type: "contourRef";
    contourRef: ContourRefShape;
}
interface InputShape_dataHealthCheck {
    type: "dataHealthCheck";
    dataHealthCheck: DataHealthCheckShape;
}
interface InputShape_dataHealthCheckGroup {
    type: "dataHealthCheckGroup";
    dataHealthCheckGroup: DataHealthCheckGroupShape;
}
interface InputShape_datasourceColumn {
    type: "datasourceColumn";
    datasourceColumn: DatasourceColumnShape;
}
interface InputShape_deployedApp {
    type: "deployedApp";
    deployedApp: DeployedAppShape;
}
interface InputShape_eddieParameter {
    type: "eddieParameter";
    eddieParameter: EddieParameterShape;
}
interface InputShape_eddieParameterV2 {
    type: "eddieParameterV2";
    eddieParameterV2: EddieParameterShapeV2;
}
interface InputShape_eddiePipeline {
    type: "eddiePipeline";
    eddiePipeline: EddiePipelineShape;
}
interface InputShape_eddieReplayOption {
    type: "eddieReplayOption";
    eddieReplayOption: EddieReplayOptionShape;
}
interface InputShape_eddieGeotimeConfiguration {
    type: "eddieGeotimeConfiguration";
    eddieGeotimeConfiguration: EddieGeotimeConfigurationInputShape;
}
interface InputShape_eddieEdgeParameter {
    type: "eddieEdgeParameter";
    eddieEdgeParameter: EddieEdgeParameterInputShape;
}
interface InputShape_edgePipelineMagritteSource {
    type: "edgePipelineMagritteSource";
    edgePipelineMagritteSource: EdgePipelineMagritteSourceInputShape;
}
interface InputShape_evaluationSuite {
    type: "evaluationSuite";
    evaluationSuite: EvaluationSuiteShape;
}
interface InputShape_filesDatasource {
    type: "filesDatasource";
    filesDatasource: FilesDatasourceInputShape;
}
interface InputShape_flinkProfile {
    type: "flinkProfile";
    flinkProfile: FlinkProfileShape;
}
interface InputShape_function {
    type: "function";
    function: FunctionInputShape;
}
interface InputShape_functionContract {
    type: "functionContract";
    functionContract: FunctionContractShape;
}
interface InputShape_functionVersionsConfiguration {
    type: "functionVersionsConfiguration";
    functionVersionsConfiguration: FunctionVersionsConfigurationInputShape;
}
interface InputShape_functionsApiStabilityConfiguration {
    type: "functionsApiStabilityConfiguration";
    functionsApiStabilityConfiguration: FunctionsApiStabilityConfigurationInputShape;
}
interface InputShape_fusionDocument {
    type: "fusionDocument";
    fusionDocument: FusionDocumentShape;
}
interface InputShape_geotimeSeriesIntegration {
    type: "geotimeSeriesIntegration";
    geotimeSeriesIntegration: GeotimeSeriesIntegrationShape;
}
interface InputShape_interfaceType {
    type: "interfaceType";
    interfaceType: InterfaceTypeInputShape;
}
interface InputShape_interfaceLinkType {
    type: "interfaceLinkType";
    interfaceLinkType: InterfaceLinkTypeInputShape;
}
interface InputShape_interfacePropertyType {
    type: "interfacePropertyType";
    interfacePropertyType: InterfacePropertyTypeInputShape;
}
interface InputShape_interfaceActionTypeConstraint {
    type: "interfaceActionTypeConstraint";
    interfaceActionTypeConstraint: InterfaceActionTypeConstraintShape;
}
interface InputShape_interfaceParameterConstraint {
    type: "interfaceParameterConstraint";
    interfaceParameterConstraint: InterfaceParameterConstraintShape;
}
interface InputShape_installPrefix {
    type: "installPrefix";
    installPrefix: InstallPrefixShape;
}
interface InputShape_linkType {
    type: "linkType";
    linkType: LinkTypeInputShape;
}
interface InputShape_languageModel {
    type: "languageModel";
    languageModel: LanguageModelShape;
}
interface InputShape_logic {
    type: "logic";
    logic: LogicShape;
}
interface InputShape_logicFunction {
    type: "logicFunction";
    logicFunction: LogicFunctionShape;
}
interface InputShape_machinery {
    type: "machinery";
    machinery: MachineryProcessShape;
}
interface InputShape_magritteConnection {
    type: "magritteConnection";
    magritteConnection: MagritteConnectionInputShape;
}
interface InputShape_magritteExport {
    type: "magritteExport";
    magritteExport: MagritteExportShape;
}
interface InputShape_magritteSource {
    type: "magritteSource";
    magritteSource: MagritteSourceInputShape;
}
interface InputShape_magritteSourceConfigOverrides {
    type: "magritteSourceConfigOverrides";
    magritteSourceConfigOverrides: MagritteSourceConfigOverridesInputShape;
}
interface InputShape_magritteStreamingExtractConfigOverrides {
    type: "magritteStreamingExtractConfigOverrides";
    magritteStreamingExtractConfigOverrides: MagritteStreamingExtractConfigOverridesInputShape;
}
interface InputShape_markings {
    type: "markings";
    markings: MarkingsShape;
}
interface InputShape_modelStudio {
    type: "modelStudio";
    modelStudio: ModelStudioInputShape;
}
interface InputShape_model {
    type: "model";
    model: ModelInputShape;
}
interface InputShape_monitorView {
    type: "monitorView";
    monitorView: MonitorViewShape;
}
interface InputShape_monocleGraph {
    type: "monocleGraph";
    monocleGraph: MonocleGraphShape;
}
interface InputShape_multipassUserAttribute {
    type: "multipassUserAttribute";
    multipassUserAttribute: MultipassUserAttributeShape;
}
interface InputShape_multipassGroup {
    type: "multipassGroup";
    multipassGroup: MultipassGroupShape;
}
interface InputShape_namedCredential {
    type: "namedCredential";
    namedCredential: NamedCredentialShape;
}
interface InputShape_networkEgressPolicy {
    type: "networkEgressPolicy";
    networkEgressPolicy: NetworkEgressPolicyShape;
}
interface InputShape_notepadDocument {
    type: "notepadDocument";
    notepadDocument: NotepadDocumentShape;
}
interface InputShape_notepadTemplate {
    type: "notepadTemplate";
    notepadTemplate: NotepadTemplateShape;
}
interface InputShape_notepadTemplateParameter {
    type: "notepadTemplateParameter";
    notepadTemplateParameter: NotepadTemplateParameterShape;
}
interface InputShape_objectInstance {
    type: "objectInstance";
    objectInstance: ObjectInstanceInputShape;
}
interface InputShape_objectSet {
    type: "objectSet";
    objectSet: ObjectSetShape;
}
interface InputShape_objectType {
    type: "objectType";
    objectType: ObjectTypeInputShape;
}
interface InputShape_objectView {
    type: "objectView";
    objectView: ObjectViewShape;
}
interface InputShape_objectViewTab {
    type: "objectViewTab";
    objectViewTab: ObjectViewTabShape;
}
interface InputShape_ontologyDatasource {
    type: "ontologyDatasource";
    ontologyDatasource: OntologyDatasourceShape;
}
interface InputShape_ontologyDatasourceRetention {
    type: "ontologyDatasourceRetention";
    ontologyDatasourceRetention: OntologyDatasourceRetentionShape;
}
interface InputShape_ontologySdk {
    type: "ontologySdk";
    ontologySdk: OntologySdkShape;
}
interface InputShape_overrideOntologyEntityApiNames {
    type: "overrideOntologyEntityApiNames";
    overrideOntologyEntityApiNames: OverrideOntologyEntityApiNamesShape;
}
interface InputShape_parameter {
    type: "parameter";
    parameter: ParameterInputShape;
}
interface InputShape_peerProducerProfile {
    type: "peerProducerProfile";
    peerProducerProfile: PeerProducerProfileShape;
}
interface InputShape_peerProfile {
    type: "peerProfile";
    peerProfile: PeerProfileShape;
}
interface InputShape_peerProfileRemoteStrategy {
    type: "peerProfileRemoteStrategy";
    peerProfileRemoteStrategy: PeerProfileRemoteStrategyShape;
}
interface InputShape_property {
    type: "property";
    property: PropertyInputShape;
}
interface InputShape_quiverDashboard {
    type: "quiverDashboard";
    quiverDashboard: QuiverDashboardShape;
}
interface InputShape_schedule {
    type: "schedule";
    schedule: ScheduleShape;
}
interface InputShape_sharedPropertyType {
    type: "sharedPropertyType";
    sharedPropertyType: SharedPropertyTypeInputShape;
}
interface InputShape_slateApplication {
    type: "slateApplication";
    slateApplication: SlateApplicationInputShape;
}
interface InputShape_storedProcedure {
    type: "storedProcedure";
    storedProcedure: StoredProcedureShape;
}
interface InputShape_solutionDesign {
    type: "solutionDesign";
    solutionDesign: SolutionDesignShape;
}
interface InputShape_sparkProfile {
    type: "sparkProfile";
    sparkProfile: SparkProfileShape;
}
interface InputShape_tabularDatasource {
    type: "tabularDatasource";
    tabularDatasource: TabularDatasourceInputShape;
}
interface InputShape_taurusWorkflow {
    type: "taurusWorkflow";
    taurusWorkflow: TaurusWorkflowShape;
}
interface InputShape_thirdPartyApplication {
    type: "thirdPartyApplication";
    thirdPartyApplication: ThirdPartyApplicationShape;
}
interface InputShape_timeSeriesSync {
    type: "timeSeriesSync";
    timeSeriesSync: TimeSeriesSyncShape;
}
interface InputShape_valueType {
    type: "valueType";
    valueType: ValueTypeShape;
}
interface InputShape_vectorWorkbook {
    type: "vectorWorkbook";
    vectorWorkbook: VectorWorkbookShape;
}
interface InputShape_versionedObjectSet {
    type: "versionedObjectSet";
    versionedObjectSet: VersionedObjectSetShape;
}
interface InputShape_vertexTemplate {
    type: "vertexTemplate";
    vertexTemplate: VertexTemplateShape;
}
interface InputShape_vortexTemplate {
    type: "vortexTemplate";
    vortexTemplate: VortexTemplateShape;
}
interface InputShape_walkthrough {
    type: "walkthrough";
    walkthrough: WalkthroughShape;
}
interface InputShape_webhook {
    type: "webhook";
    webhook: WebhookShape;
}
interface InputShape_widget {
    type: "widget";
    widget: WidgetShape;
}
interface InputShape_widgetSet {
    type: "widgetSet";
    widgetSet: WidgetSetShape;
}
interface InputShape_workbenchTemplate {
    type: "workbenchTemplate";
    workbenchTemplate: WorkbenchTemplateShape;
}
interface InputShape_workflowBuilderGraph {
    type: "workflowBuilderGraph";
    workflowBuilderGraph: WorkflowBuilderGraphShape;
}
interface InputShape_workflowGraph {
    type: "workflowGraph";
    workflowGraph: WorkflowGraphShape;
}
interface InputShape_sqlWorksheet {
    type: "sqlWorksheet";
    sqlWorksheet: SqlWorksheetShape;
}
interface InputShape_workshopApplication {
    type: "workshopApplication";
    workshopApplication: WorkshopApplicationInputShape;
}
interface InputShape_workshopApplicationSaveLocation {
    type: "workshopApplicationSaveLocation";
    workshopApplicationSaveLocation: WorkshopApplicationSaveLocationInputShape;
}
/**
 * An input must have an about field of type `LocalizedTitleAndDescription`. This is what the FE uses to render
 * the input. Users may override this default about about using `updatePendingInputShapeAbout`.
 */
type InputShape = InputShape_action | InputShape_actionParameter | InputShape_allowOntologySchemaMigrations | InputShape_aipAgent | InputShape_artifactsRepository | InputShape_authoringLibrary | InputShape_authoringRepository | InputShape_automation | InputShape_autopilotWorkbench | InputShape_carbonWorkspace | InputShape_cipherLicense | InputShape_cipherLicenseV2 | InputShape_blobsterResource | InputShape_cipherChannel | InputShape_codeWorkspace | InputShape_codeWorkspaceLicense | InputShape_compassResource | InputShape_contourAnalysis | InputShape_contourRef | InputShape_dataHealthCheck | InputShape_dataHealthCheckGroup | InputShape_datasourceColumn | InputShape_deployedApp | InputShape_eddieParameter | InputShape_eddieParameterV2 | InputShape_eddiePipeline | InputShape_eddieReplayOption | InputShape_eddieGeotimeConfiguration | InputShape_eddieEdgeParameter | InputShape_edgePipelineMagritteSource | InputShape_evaluationSuite | InputShape_filesDatasource | InputShape_flinkProfile | InputShape_function | InputShape_functionContract | InputShape_functionVersionsConfiguration | InputShape_functionsApiStabilityConfiguration | InputShape_fusionDocument | InputShape_geotimeSeriesIntegration | InputShape_interfaceType | InputShape_interfaceLinkType | InputShape_interfacePropertyType | InputShape_interfaceActionTypeConstraint | InputShape_interfaceParameterConstraint | InputShape_installPrefix | InputShape_linkType | InputShape_languageModel | InputShape_logic | InputShape_logicFunction | InputShape_machinery | InputShape_magritteConnection | InputShape_magritteExport | InputShape_magritteSource | InputShape_magritteSourceConfigOverrides | InputShape_magritteStreamingExtractConfigOverrides | InputShape_markings | InputShape_modelStudio | InputShape_model | InputShape_monitorView | InputShape_monocleGraph | InputShape_multipassUserAttribute | InputShape_multipassGroup | InputShape_namedCredential | InputShape_networkEgressPolicy | InputShape_notepadDocument | InputShape_notepadTemplate | InputShape_notepadTemplateParameter | InputShape_objectInstance | InputShape_objectSet | InputShape_objectType | InputShape_objectView | InputShape_objectViewTab | InputShape_ontologyDatasource | InputShape_ontologyDatasourceRetention | InputShape_ontologySdk | InputShape_overrideOntologyEntityApiNames | InputShape_parameter | InputShape_peerProducerProfile | InputShape_peerProfile | InputShape_peerProfileRemoteStrategy | InputShape_property | InputShape_quiverDashboard | InputShape_schedule | InputShape_sharedPropertyType | InputShape_slateApplication | InputShape_storedProcedure | InputShape_solutionDesign | InputShape_sparkProfile | InputShape_tabularDatasource | InputShape_taurusWorkflow | InputShape_thirdPartyApplication | InputShape_timeSeriesSync | InputShape_valueType | InputShape_vectorWorkbook | InputShape_versionedObjectSet | InputShape_vertexTemplate | InputShape_vortexTemplate | InputShape_walkthrough | InputShape_webhook | InputShape_widget | InputShape_widgetSet | InputShape_workbenchTemplate | InputShape_workflowBuilderGraph | InputShape_workflowGraph | InputShape_sqlWorksheet | InputShape_workshopApplication | InputShape_workshopApplicationSaveLocation;
interface InputShapeMetadata {
    isAccessedInReconcile: boolean;
    isOptional: boolean;
    preallocateAccessRequirements?: PreallocateAccessRequirementType | null | undefined;
    reconcileAccessRequirements?: ReconcileAccessRequirementType | null | undefined;
}
interface InputShapeNotSpecified {
    blockVersionId: BlockVersionId;
    inputShape: BlockShapeId;
    requiredForInputGroupIds: Array<InputGroupId>;
}
interface InputShapeResolver_apiNameResolver {
    type: "apiNameResolver";
    apiNameResolver: ApiNameResolver;
}
interface InputShapeResolver_resolvedShapeResolver {
    type: "resolvedShapeResolver";
    resolvedShapeResolver: ResolvedBlockSetInputShape;
}
interface InputShapeResolver_linkTypeIdResolver {
    type: "linkTypeIdResolver";
    linkTypeIdResolver: LinkTypeIdResolver;
}
interface InputShapeResolver_multipassGroupResolver {
    type: "multipassGroupResolver";
    multipassGroupResolver: MultipassGroupResolver;
}
interface InputShapeResolver_markingsResolver {
    type: "markingsResolver";
    markingsResolver: Array<MarkingResolver>;
}
interface InputShapeResolver_valueTypePresetResolver {
    type: "valueTypePresetResolver";
    valueTypePresetResolver: ValueTypePresetResolver;
}
/**
 * Used to generate a resolved block set input shape.
 */
type InputShapeResolver = InputShapeResolver_apiNameResolver | InputShapeResolver_resolvedShapeResolver | InputShapeResolver_linkTypeIdResolver | InputShapeResolver_multipassGroupResolver | InputShapeResolver_markingsResolver | InputShapeResolver_valueTypePresetResolver;
interface InputShapeResult {
    blockShapeId: BlockShapeId;
    internalShapeId: InternalShapeId;
    metadata: InputShapeMetadata;
    resolvedShape?: ResolvedInputShape | null | undefined;
    shape: InputShape;
}
/**
 * Corresponds 1:1 with the member types of the InputShape union.
 *
 * NOTE: The name here needs to be identical to the name in `OutputShapeType` for the same shape type.
 */
type InputShapeType = "ACTION" | "ACTION_PARAMETER" | "ALLOW_SCHEMA_MIGRATIONS" | "AIP_AGENT" | "ARTIFACTS_REPOSITORY" | "AUTHORING_LIBRARY" | "AUTHORING_REPOSITORY" | "AUTOMATION" | "AUTOPILOT_WORKBENCH" | "BLOBSTER_RESOURCE" | "CARBON_WORKSPACE" | "CIPHER_CHANNEL" | "CIPHER_LICENSE" | "CIPHER_LICENSE_V2" | "CODE_WORKSPACE" | "CODE_WORKSPACE_LICENSE" | "COMPASS_RESOURCE" | "CONTOUR_ANALYSIS" | "CONTOUR_REF" | "DATA_HEALTH_CHECK" | "DATA_HEALTH_CHECK_GROUP" | "DATASOURCE_COLUMN" | "DEPLOYED_APP" | "EDDIE_PARAMETER" | "EDDIE_PARAMETER_V2" | "EDDIE_PIPELINE" | "EDDIE_REPLAY_OPTION" | "EDDIE_GEOTIME_CONFIGURATION" | "EDDIE_EDGE_PARAMETER" | "EDGE_PIPELINE_MAGRITTE_SOURCE_CONFIGURATION" | "EVALUATION_SUITE" | "FILES_DATASOURCE" | "FLINK_PROFILE" | "FUNCTION" | "FUNCTION_CONTRACT" | "FUNCTION_VERSIONS_CONFIGURATION" | "FUNCTIONS_API_STABILITY_CONFIGURATION" | "FUSION_DOCUMENT" | "GEOTIME_SERIES_INTEGRATION" | "INTERFACE_TYPE" | "INTERFACE_LINK_TYPE" | "INTERFACE_PROPERTY_TYPE" | "INTERFACE_ACTION_TYPE_CONSTRAINT" | "INTERFACE_PARAMETER_CONSTRAINT" | "INSTALL_PREFIX" | "LANGUAGE_MODEL" | "LINK_TYPE" | "LOGIC" | "LOGIC_FUNCTION" | "MACHINERY" | "MAGRITTE_CONNECTION" | "MAGRITTE_EXPORT" | "MAGRITTE_SOURCE" | "MAGRITTE_SOURCE_CONFIG_OVERRIDES" | "MAGRITTE_STREAMING_EXTRACT_CONFIG_OVERRIDES" | "MARKINGS" | "MODEL_STUDIO" | "MODEL" | "MONITOR_VIEW" | "MONOCLE_GRAPH" | "MULTIPASS_USER_ATTRIBUTE" | "MULTIPASS_GROUP" | "NAMED_CREDENTIAL" | "NETWORK_EGRESS_POLICY" | "NOTEPAD_DOCUMENT" | "NOTEPAD_TEMPLATE" | "NOTEPAD_TEMPLATE_PARAMETER" | "OBJECT_INSTANCE" | "OBJECT_SET" | "OBJECT_TYPE" | "OBJECT_VIEW" | "OBJECT_VIEW_TAB" | "ONTOLOGY_DATASOURCE" | "ONTOLOGY_DATASOURCE_RETENTION" | "ONTOLOGY_SDK" | "OVERRIDE_ONTOLOGY_ENTITY_API_NAMES" | "PARAMETER" | "PEER_PRODUCER_PROFILE" | "PEER_PROFILE" | "PEER_PROFILE_REMOTE_STRATEGY" | "PROPERTY" | "QUIVER_DASHBOARD" | "SCHEDULE" | "SHARED_PROPERTY_TYPE" | "SLATE_APPLICATION" | "STORED_PROCEDURE" | "SOLUTION_DESIGN" | "SPARK_PROFILE" | "TABULAR_DATASOURCE" | "TAURUS_WORKFLOW" | "THIRD_PARTY_APPLICATION" | "TIME_SERIES_SYNC" | "VALUE_TYPE" | "VECTOR_WORKBOOK" | "VERSIONED_OBJECT_SET" | "VERTEX_TEMPLATE" | "VORTEX_TEMPLATE" | "WALKTHROUGH" | "WEBHOOK" | "WIDGET" | "WIDGET_SET" | "WORKBENCH_TEMPLATE" | "WORKFLOW_BUILDER_GRAPH" | "WORKFLOW_GRAPH" | "SQL_WORKSHEET" | "WORKSHOP_APPLICATION" | "WORKSHOP_APPLICATION_SAVE_LOCATION";
/**
 * Represents an input shape version, and output shapes of the block that has this input.
 */
interface InputShapeVersionAndBlockSetOutputs {
    outputs: Array<OutputBlockSetShapeId>;
    version?: ResourceVersion | null | undefined;
}
type InstallableBlockSetInputGroups = Record<BlockSetInputGroupId, BlockSetInputGroup>;
interface InstallableBlockSetInputShape {
    isOptional: boolean;
    metadata?: InstallableInputBlockSetShapeMetadata | null | undefined;
    shape: BlockSetInputShape;
}
type InstallableBlockSetInputShapes = Record<InputBlockSetShapeId, InstallableBlockSetInputShape>;
interface InstallableBlockSetOutputShape {
    producedByBlockType: BlockType;
    shape: BlockSetOutputShape;
}
type InstallableBlockSetOutputShapes = Record<OutputBlockSetShapeId, InstallableBlockSetOutputShape>;
/**
 * Installable version of BlockSetShapeDependencies, which doesn't include the block metadata.
 */
interface InstallableBlockSetShapeDependencies {
    dependencies: OutputShapeDependencies;
    outputs: Array<OutputBlockSetShapeId>;
}
interface InstallableBlockSetVersionDocumentation {
    attachments: Array<AttachmentMetadata>;
    changelog?: Changelog | null | undefined;
    freeForm?: FreeFormDocumentation | null | undefined;
    freeFormSections?: FreeFormDocumentationSections | null | undefined;
    links?: Links | null | undefined;
    localizedFreeFormSections?: LocalizedFreeFormDocumentationSections | null | undefined;
    thumbnail?: AttachmentMetadata | null | undefined;
}
/**
 * An installable block set version always needs to be identified through a tuple of
 * (MarketplaceRid, BlockSetVersionId).
 */
interface InstallableBlockSetVersionId {
    blockSetVersionId: BlockSetVersionId;
    marketplaceRid: MarketplaceRid;
}
interface InstallableBlockSetVersionMetadata {
    about: LocalizedTitleAndDescription;
    asCodeBlockSetMetadata?: AsCodeBlockSetMetadata | null | undefined;
    createdByUser?: MultipassUserId | null | undefined;
    creationTimestamp: string;
    defaultInstallationSettings?: DefaultInstallationSettings | null | undefined;
    id: BlockSetId;
    importedAt?: ImportTimestamp | null | undefined;
    lastKnownVersionBeforeBreak?: SemverVersion | null | undefined;
    marketplaceMetadataVersion?: MarketplaceMetadataVersion | null | undefined;
    mavenProductId?: MavenProductId | null | undefined;
    publishedByUser?: MultipassUserId | null | undefined;
    releaseMetadata: BlockSetVersionReleaseMetadata;
    tags: Array<BlockSetTag>;
    tagsV2: BlockSetCategorizedTags;
    typedTags: Array<TagRid>;
    version: BlockSetVersion;
    versionId: BlockSetVersionId;
}
interface InstallableBlockSetVersionShapes {
    inputGroups: InstallableBlockSetInputGroups;
    inputShapes: InstallableBlockSetInputShapes;
    outputShapes: InstallableBlockSetOutputShapes;
    shapeDependencies: Array<InstallableBlockSetShapeDependencies>;
}
interface InstallableInputBlockSetShapeMetadata {
    about: InputBlockSetShapeAboutMetadata;
    presets?: InstallableInputPreset | null | undefined;
    visibility?: BlockSetShapeVisibility | null | undefined;
}
interface InstallableInputPreset {
    enforcement?: PresetEnforcement | null | undefined;
    exportCompatibility: ExportCompatibility;
    isDefault?: boolean | null | undefined;
    value: InstallablePresetValue;
}
/**
 * Installable version of `PresetResolvedShapeOverrides`. The resolved shapes are not included, so that the
 * installer is not shown resolved shapes from the source, which may originate from a different stack or
 * enrollment.
 */
interface InstallablePresetResolvedShapeOverrides {
    defaultIndex?: number | null | undefined;
    resolvers: Array<InputShapeResolver>;
}
interface InstallablePresetValue_fromSource {
    type: "fromSource";
    fromSource: PresetFromSource;
}
interface InstallablePresetValue_resolvedShapeOverrides {
    type: "resolvedShapeOverrides";
    resolvedShapeOverrides: InstallablePresetResolvedShapeOverrides;
}
type InstallablePresetValue = InstallablePresetValue_fromSource | InstallablePresetValue_resolvedShapeOverrides;
interface InstallableTransportBlock {
    changelog?: Changelog | null | undefined;
    creationTimestamp: CreationTimestamp;
    id: BlockId;
    internal: BlockInternal;
    version: BlockVersion;
    versionId: BlockVersionId;
}
interface InstallableTransportBlockSet {
    about: LocalizedTitleAndDescription;
    additionalRecommendationVariants: Record<BlockSetRecommendationId, BlockSetRecommendationVariant>;
    asCodeBlockSetMetadata?: AsCodeBlockSetMetadata | null | undefined;
    blocks: Record<BlockSetBlockInstanceId, SingleVersionBlockReference>;
    blockSetShapeMapping?: TransportBlockSetToBlockMapping | null | undefined;
    changelog?: Changelog | null | undefined;
    creationTimestamp: CreationTimestamp;
    defaultInstallationSettings?: DefaultInstallationSettings | null | undefined;
    documentation?: BlockSetDocumentation | null | undefined;
    externalRecommendations: Array<ExternalRecommendationV2>;
    id: BlockSetId;
    installHints?: BlockSetInstallationHints | null | undefined;
    lastKnownVersionBeforeBreak?: BlockSetVersion | null | undefined;
    marketplaceMetadata?: TransportVersionedMarketplaceMetadata | null | undefined;
    mavenCoordinateDependencies: Array<MavenCoordinateDependency>;
    mavenProductId?: MavenProductId | null | undefined;
    packagingMetadata?: TransportPackagingMetadata | null | undefined;
    releaseMetadata?: TransportReleaseMetadata | null | undefined;
    tags: Array<BlockSetTag>;
    tagsV2?: BlockSetCategorizedTags | null | undefined;
    typedTags: Array<TagRid>;
    version: BlockSetVersion;
    versionId: BlockSetVersionId;
}
interface InstallationBuild {
    buildRid: BuildRid;
    shapeBuildJobs: Record<OutputBlockSetShapeId, JobRid>;
}
type InstallationContextId = string;
interface InstallationInstruction_installNewBlock {
    type: "installNewBlock";
    installNewBlock: InstallNewBlockInstruction;
}
interface InstallationInstruction_installExistingBlock {
    type: "installExistingBlock";
    installExistingBlock: InstallExistingBlockInstruction;
}
type InstallationInstruction = InstallationInstruction_installNewBlock | InstallationInstruction_installExistingBlock;
interface InstallationJobBuildAll {
}
interface InstallationJobBuildOption_all {
    type: "all";
    all: InstallationJobBuildAll;
}
interface InstallationJobBuildOption_required {
    type: "required";
    required: InstallationJobBuildRequired;
}
type InstallationJobBuildOption = InstallationJobBuildOption_all | InstallationJobBuildOption_required;
interface InstallationJobBuildRequired {
}
interface InstallationJobValidationError_externalRecommendationToSelf {
    type: "externalRecommendationToSelf";
    externalRecommendationToSelf: ExternalRecommendationToSelf;
}
interface InstallationJobValidationError_invalidNewBlockSetInstallationReferences {
    type: "invalidNewBlockSetInstallationReferences";
    invalidNewBlockSetInstallationReferences: InvalidNewBlockSetInstallationReferences;
}
interface InstallationJobValidationError_invalidPreallocatedJobRid {
    type: "invalidPreallocatedJobRid";
    invalidPreallocatedJobRid: Void;
}
interface InstallationJobValidationError_noInstallationsInRequest {
    type: "noInstallationsInRequest";
    noInstallationsInRequest: Void;
}
interface InstallationJobValidationError_numberOfInstallationsInRequestLimitExceeded {
    type: "numberOfInstallationsInRequestLimitExceeded";
    numberOfInstallationsInRequestLimitExceeded: NumberOfInstallationsInRequestLimitExceeded;
}
interface InstallationJobValidationError_duplicateBlockSetVersionsInRequest {
    type: "duplicateBlockSetVersionsInRequest";
    duplicateBlockSetVersionsInRequest: DuplicateBlockSetVersionsInRequest;
}
interface InstallationJobValidationError_unresolvableCycle {
    type: "unresolvableCycle";
    unresolvableCycle: UnresolvableBlockSetCycle;
}
interface InstallationJobValidationError_serializable {
    type: "serializable";
    serializable: MarketplaceSerializableError;
}
type InstallationJobValidationError = InstallationJobValidationError_externalRecommendationToSelf | InstallationJobValidationError_invalidNewBlockSetInstallationReferences | InstallationJobValidationError_invalidPreallocatedJobRid | InstallationJobValidationError_noInstallationsInRequest | InstallationJobValidationError_numberOfInstallationsInRequestLimitExceeded | InstallationJobValidationError_duplicateBlockSetVersionsInRequest | InstallationJobValidationError_unresolvableCycle | InstallationJobValidationError_serializable;
interface InstallationJobValidationErrorV2 {
    error: InstallationJobValidationError;
    severity: ErrorSeverity;
}
interface InstallationMode_bootstrap {
    type: "bootstrap";
    bootstrap: Void;
}
interface InstallationMode_production {
    type: "production";
    production: Void;
}
interface InstallationMode_singleton {
    type: "singleton";
    singleton: Void;
}
/**
 * The installation mode associated with the product. The expectation is that integrators do not do anything with
 * bootstrap or production. For singleton the expectation is that integrations validate and enforce api name
 * uniqueness in the namespace/ontology.
 */
type InstallationMode = InstallationMode_bootstrap | InstallationMode_production | InstallationMode_singleton;
interface InstallationOutputKey_rid {
    type: "rid";
    rid: RidShapeIdentifier;
}
interface InstallationOutputKey_objectViewTab {
    type: "objectViewTab";
    objectViewTab: ObjectViewTabIdentifier;
}
interface InstallationOutputKey_rosettaDocsBundle {
    type: "rosettaDocsBundle";
    rosettaDocsBundle: RosettaProductId;
}
interface InstallationOutputKey_ontologySdk {
    type: "ontologySdk";
    ontologySdk: OntologySdkIdentifier;
}
interface InstallationOutputKey_logicFunction {
    type: "logicFunction";
    logicFunction: LogicFunctionShapeIdentifier;
}
/**
 * This uniquely represents an installed resource.
 *
 * For shapes where marketplace owns the entire resource, we can use the rid to identify the output.
 * For more complex cases, we can add new union members and encode additional metadata to identify the resource.
 */
type InstallationOutputKey = InstallationOutputKey_rid | InstallationOutputKey_objectViewTab | InstallationOutputKey_rosettaDocsBundle | InstallationOutputKey_ontologySdk | InstallationOutputKey_logicFunction;
interface InstallationOutputMetadata {
    blockInstallationRid: BlockInstallationRid;
    blockSetBlockInstanceId: BlockSetBlockInstanceId;
    blockSetInstallationRid: BlockSetInstallationRid;
    blockSetShapeId?: BlockSetShapeId | null | undefined;
    blockShapeId: BlockShapeId;
    blockVersionId: BlockVersionId;
}
/**
 * A member sourced from an installation.
 */
interface InstallationProductGroupMember {
    blockSetInstallationRid: BlockSetInstallationRid;
}
/**
 * MARKETPLACE_INSTALLATION will lead to a project where all edit permissions are disabled, PROJECT will lead to a regular project being created
 */
type InstallationProjectRoleContext = "MARKETPLACE_INSTALLATION" | "PROJECT";
interface InstallationResolvedInputShape {
    value: InstallationResolvedInputShapeValue;
}
interface InstallationResolvedInputShapeFromDefault {
    expectedResolvedShape?: ResolvedBlockSetInputShape | null | undefined;
}
interface InstallationResolvedInputShapeManuallyProvided {
    resolvedShape: ResolvedBlockSetInputShape;
}
interface InstallationResolvedInputShapeValue_manuallyProvided {
    type: "manuallyProvided";
    manuallyProvided: InstallationResolvedInputShapeManuallyProvided;
}
interface InstallationResolvedInputShapeValue_fromDefault {
    type: "fromDefault";
    fromDefault: InstallationResolvedInputShapeFromDefault;
}
type InstallationResolvedInputShapeValue = InstallationResolvedInputShapeValue_manuallyProvided | InstallationResolvedInputShapeValue_fromDefault;
type InstallationTimestamp = string;
/**
 * Settings for upgrade automation related settings.
 */
interface InstallAutomationSettings {
    automaticUpgradesEnabled: boolean;
    maintenanceWindows: MaintenanceWindows;
    notificationSettings?: NotificationMechanismsTargets | null | undefined;
    releaseChannels: Array<ReleaseChannel>;
}
interface InstallBlockFinishedMetadata {
    blockReference: BlockReference;
    blockShapeBuildMetadata: Record<BlockShapeId, BlockShapeBuildMetadata>;
    buildsAndIndexingIds: Record<BlockShapeId, BuildsAndIndexingIds>;
}
interface InstallBlockSetPermissionDeniedRationale {
    blockSetId: BlockSetId;
    marketplaceRid: MarketplaceRid;
    securityRid: BlockSetSecurityRid;
}
/**
 * Maps 1:1 to a InstallShapeValidationError, but any block internal ids would map to block set shape ids
 */
type InstallBlockSetShapeValidationError = InstallShapeValidationError;
/**
 * A single Namespace and at most one Ontology must be provided in the request.
 */
interface InstallBlockSetsRequest {
    createNewInstallations: Record<NewBlockSetInstallationId, CreateNewBlockSetInstallation>;
    createProjects: Record<NewProjectId, CreateProjectRequest>;
    jobSettings?: JobSettings | null | undefined;
    modifyExistingInstallations: Record<BlockSetInstallationRid, ModifyExistingBlockSetInstallation>;
    preallocatedJobRid?: BlockSetInstallationJobRid | null | undefined;
}
interface InstallBlockSetsResponse {
    result: InstallBlockSetsResult;
}
interface InstallBlockSetsResult_jobSubmitted {
    type: "jobSubmitted";
    jobSubmitted: JobSubmittedResult;
}
interface InstallBlockSetsResult_failedToSubmitJob {
    type: "failedToSubmitJob";
    failedToSubmitJob: FailedToSubmitJobResult;
}
interface InstallBlockSetsResult_invalidRequest {
    type: "invalidRequest";
    invalidRequest: InvalidInstallBlockSetsRequest;
}
type InstallBlockSetsResult = InstallBlockSetsResult_jobSubmitted | InstallBlockSetsResult_failedToSubmitJob | InstallBlockSetsResult_invalidRequest;
type InstallBlocksJobId = string;
type InstallBlocksJobRid = string;
interface InstallBlocksRequest {
    associatedBlockSetInstalls: Array<AssociatedBlockSetInstallation>;
    installationInstructions: Array<InstallationInstruction>;
}
interface InstallBlocksRequestV2 {
    blockSetVersionToStore: Record<BlockSetVersionId, MarketplaceRid>;
    blockVersionToStore: Record<BlockVersionId, MarketplaceRid>;
    buildSettings?: BuildSettings | null | undefined;
    cleanupUnusedShapesSettings?: CleanupUnusedShapesSettings | null | undefined;
    installLocation: TargetInstallLocation;
    marketplaceRid: MarketplaceRid;
    request: InstallBlocksRequest;
}
interface InstallBlocksResponseV2_inProgress {
    type: "inProgress";
    inProgress: InstallBlocksJobRid;
}
interface InstallBlocksResponseV2_invalidRequest {
    type: "invalidRequest";
    invalidRequest: InvalidInstallBlocksRequest;
}
interface InstallBlocksResponseV2_failed {
    type: "failed";
    failed: FailedInstallBlocksResponse;
}
type InstallBlocksResponseV2 = InstallBlocksResponseV2_inProgress | InstallBlocksResponseV2_invalidRequest | InstallBlocksResponseV2_failed;
interface InstallBlocksStatus_pending {
    type: "pending";
    pending: InstallBlocksStatusPending;
}
interface InstallBlocksStatus_building {
    type: "building";
    building: InstallBlocksStatusBuilding;
}
interface InstallBlocksStatus_success {
    type: "success";
    success: InstallBlocksStatusSuccess;
}
interface InstallBlocksStatus_error {
    type: "error";
    error: InstallBlocksStatusError;
}
type InstallBlocksStatus = InstallBlocksStatus_pending | InstallBlocksStatus_building | InstallBlocksStatus_success | InstallBlocksStatus_error;
/**
 * Status for an in progress job, where backing datasources are building. Install pending metadata provides a
 * granular install status per block in the installation lifecycle.
 */
interface InstallBlocksStatusBuilding {
    awaitingCancellation?: BlockReference | null | undefined;
    inProgressMetadata: Array<InstallPendingMetadata>;
    newBlockSetInstallationRids: Record<NewBlockSetInstallationId, BlockSetInstallationRid>;
}
/**
 * Status of an errored block installation. Provides block level breakdown and a global set of installation errors.
 */
interface InstallBlocksStatusError {
    blockShapeBuildMetadata: Record<BlockShapeId, BlockShapeBuildMetadata>;
    erroredExisting: Record<BlockInstallationRid, Array<BlockInstallError>>;
    erroredNew: Record<InstallNewBlockInstructionId, Array<BlockInstallError>>;
    errors: Array<BlockInstallError>;
    finished: Array<BlockReference>;
    granularErrorStatus?: GranularErrorStatus | null | undefined;
    newBlockSetInstallationRids: Record<NewBlockSetInstallationId, BlockSetInstallationRid>;
    notAttempted: Array<BlockReference>;
    wasCancelled?: boolean | null | undefined;
}
/**
 * Status for an in progress job. Install pending metadata provides a granular install status per block in the
 * installation lifecycle.
 */
interface InstallBlocksStatusPending {
    awaitingCancellation?: BlockReference | null | undefined;
    finished: Array<BlockReference>;
    inProgress: Array<BlockReference>;
    inProgressMetadata: Array<InstallPendingMetadata>;
    newBlockSetInstallationRids: Record<NewBlockSetInstallationId, BlockSetInstallationRid>;
}
/**
 * Blocks have successfully completed installation.
 */
interface InstallBlocksStatusSuccess {
    finishedMetadata: Array<InstallBlockFinishedMetadata>;
    newBlockInstallationRids: Record<InstallNewBlockInstructionId, BlockInstallationRid>;
    newBlockSetInstallationRids: Record<NewBlockSetInstallationId, BlockSetInstallationRid>;
    postInstallationJobTasks: Array<PostInstallationJobTask>;
}
interface InstallExistingBlockInstruction {
    blockInstallationRid: BlockInstallationRid;
    forceInstall?: boolean | null | undefined;
    resolvedInputGroups: Record<InputGroupId, ResolvedInputGroup>;
    resolvedInputShapes: Record<BlockShapeId, ResolvedInputOrRef>;
    resolvedOutputShapes: Record<BlockShapeId, ResolvedOutputShape>;
    resolvedOutputShapesToAttach: Record<BlockShapeId, ResolvedOutputShape>;
    toVersion: BlockVersionId;
}
interface InstallFromMarketplacePermissionDeniedRationale {
    marketplaceRid: MarketplaceRid;
}
interface InstallInOntologyPermissionDeniedRationale {
    ontologyRid: OntologyRid;
}
type InstallLocationBlockShapeId = BlockShapeId;
interface InstallNewBlockInstruction {
    blockVersionId: BlockVersionId;
    id: InstallNewBlockInstructionId;
    resolvedInputGroups: Record<InputGroupId, ResolvedInputGroup>;
    resolvedInputShapes: Record<BlockShapeId, ResolvedInputOrRef>;
    resolvedOutputShapes: Record<BlockShapeId, ResolvedOutputShape>;
    resolvedOutputShapesToAttach: Record<BlockShapeId, ResolvedOutputShape>;
}
type InstallNewBlockInstructionId = string;
/**
 * Per block. Metadata provides a granular install status for a pending block installation lifecycle.
 */
interface InstallPendingMetadata {
    blockReference: BlockReference;
    granularInstallPendingStatus: GranularInstallPendingStatus;
}
/**
 * Configuration for ontology entity descriptor prefixing. DISPLAY_NAME_ONLY will only apply the configured
 * prefix to ontology entity display names. DISPLAY_NAME_AND_API_NAME will apply the configured prefix to both
 * the ontology entity display name and the API name. Note that entity IDs are not affected by the installPrefix.
 */
type InstallPrefixConfigurationEnum = "DISPLAY_NAME_ONLY" | "DISPLAY_NAME_AND_API_NAME";
/**
 * This shape is intended to represent a user-provided string input that will be applied
 * as a prefix to display names of output resources. The mechanism for applying this prefix
 * will depend on the service responsible for creating the resource and the resource type.
 *
 * For example a prefix "demo" applied to an Object Type with display name "Passenger" will
 * result in the display name being "[Demo] Passenger".
 *
 * A few constraints that Marketplace will enforce:
 * - Within a block-set all blocks must use the same prefix. At packaging time the `ResolvedInstallPrefixShape`
 * should have "" (empty string) prefix so prefix inputs from across blocks will all get
 * coalesced by Installation Hints.
 * - For every block there can only be at most one InstallPrefix input, else the mapping of prefix -> output
 * resource becomes ambiguous.
 */
interface InstallPrefixShape {
    about: LocalizedTitleAndDescription;
}
interface InstallShapeValidationError_apiNameMismatch {
    type: "apiNameMismatch";
    apiNameMismatch: StringMismatchError;
}
interface InstallShapeValidationError_actionParameterShapeErrors {
    type: "actionParameterShapeErrors";
    actionParameterShapeErrors: Record<ActionParameterShapeId, BlockInstallActionParameterTypeShapeError>;
}
interface InstallShapeValidationError_actionTypeParameterNotFound {
    type: "actionTypeParameterNotFound";
    actionTypeParameterNotFound: ActionParameterNotFound;
}
interface InstallShapeValidationError_actionTypeParameterShapeErrorV2 {
    type: "actionTypeParameterShapeErrorV2";
    actionTypeParameterShapeErrorV2: BlockInstallActionTypeParameterShapeErrorV2;
}
interface InstallShapeValidationError_actionTypeWithNestedParameters {
    type: "actionTypeWithNestedParameters";
    actionTypeWithNestedParameters: Void;
}
interface InstallShapeValidationError_attachedOutputCreatedInAnotherInstallation {
    type: "attachedOutputCreatedInAnotherInstallation";
    attachedOutputCreatedInAnotherInstallation: AttachedOutputCreatedInAnotherInstallation;
}
interface InstallShapeValidationError_attachedOutputShapeNotSpecified {
    type: "attachedOutputShapeNotSpecified";
    attachedOutputShapeNotSpecified: AttachedOutputShapeNotSpecified;
}
interface InstallShapeValidationError_attachNotSupported {
    type: "attachNotSupported";
    attachNotSupported: Void;
}
interface InstallShapeValidationError_authoringLibraryNotFound {
    type: "authoringLibraryNotFound";
    authoringLibraryNotFound: AuthoringLibraryNotFoundError;
}
interface InstallShapeValidationError_blobsterResourceShapeError {
    type: "blobsterResourceShapeError";
    blobsterResourceShapeError: BlockInstallBlobsterResourceShapeError;
}
interface InstallShapeValidationError_cipherChannelAlgorithmMismatch {
    type: "cipherChannelAlgorithmMismatch";
    cipherChannelAlgorithmMismatch: CipherChannelAlgorithmMismatch;
}
interface InstallShapeValidationError_cipherLicenseAlgorithmMismatch {
    type: "cipherLicenseAlgorithmMismatch";
    cipherLicenseAlgorithmMismatch: CipherLicenseAlgorithmMismatch;
}
interface InstallShapeValidationError_cipherLicenseMissingRequiredOperations {
    type: "cipherLicenseMissingRequiredOperations";
    cipherLicenseMissingRequiredOperations: CipherLicenseMissingRequiredOperations;
}
interface InstallShapeValidationError_cipherLicenseMissingRequiredPermits {
    type: "cipherLicenseMissingRequiredPermits";
    cipherLicenseMissingRequiredPermits: CipherLicenseMissingRequiredPermits;
}
interface InstallShapeValidationError_cipherLicenseTypeMismatch {
    type: "cipherLicenseTypeMismatch";
    cipherLicenseTypeMismatch: CipherLicenseTypeMismatch;
}
interface InstallShapeValidationError_classificationConstraintsNotSatisfied {
    type: "classificationConstraintsNotSatisfied";
    classificationConstraintsNotSatisfied: BlockInstallLocationClassificationConstraintsNotSatisfied;
}
interface InstallShapeValidationError_codeWorkspaceImageTypeMismatch {
    type: "codeWorkspaceImageTypeMismatch";
    codeWorkspaceImageTypeMismatch: CodeWorkspaceImageTypeMismatch;
}
interface InstallShapeValidationError_credentialHasIncorrectSecretNames {
    type: "credentialHasIncorrectSecretNames";
    credentialHasIncorrectSecretNames: CredentialHasIncorrectSecretNames;
}
interface InstallShapeValidationError_compassResourceInTrash {
    type: "compassResourceInTrash";
    compassResourceInTrash: BlockInstallCompassResourceInTrash;
}
interface InstallShapeValidationError_compassResourceShapeError {
    type: "compassResourceShapeError";
    compassResourceShapeError: BlockInstallCompassResourceShapeError;
}
interface InstallShapeValidationError_connectionNotFound {
    type: "connectionNotFound";
    connectionNotFound: BlockInstallConnectionNotFoundError;
}
interface InstallShapeValidationError_connectionTypeMismatch {
    type: "connectionTypeMismatch";
    connectionTypeMismatch: BlockInstallMagritteConnectionTypeMismatchError;
}
interface InstallShapeValidationError_connectionTypeUnsupported {
    type: "connectionTypeUnsupported";
    connectionTypeUnsupported: BlockInstallMagritteConnectionTypeUnsupported;
}
interface InstallShapeValidationError_connectionReferenceNotResolved {
    type: "connectionReferenceNotResolved";
    connectionReferenceNotResolved: BlockInstallConnectionReferenceUnresolvableError;
}
interface InstallShapeValidationError_connectionReferenceMismatch {
    type: "connectionReferenceMismatch";
    connectionReferenceMismatch: BlockInstallConnectionReferenceMismatchError;
}
interface InstallShapeValidationError_columnNotFound {
    type: "columnNotFound";
    columnNotFound: BlockInstallColumnNotFound;
}
interface InstallShapeValidationError_columnShapeError {
    type: "columnShapeError";
    columnShapeError: BlockInstallColumnShapeError;
}
interface InstallShapeValidationError_defaultRequestedForShapeWithNoDefault {
    type: "defaultRequestedForShapeWithNoDefault";
    defaultRequestedForShapeWithNoDefault: DefaultRequestedForShapeWithNoDefault;
}
interface InstallShapeValidationError_defaultResolutionFailedError {
    type: "defaultResolutionFailedError";
    defaultResolutionFailedError: DefaultResolutionFailedError;
}
interface InstallShapeValidationError_eddieRemoteAndPeeredDestinationsConflictError {
    type: "eddieRemoteAndPeeredDestinationsConflictError";
    eddieRemoteAndPeeredDestinationsConflictError: EddieRemoteAndPeeredDestinationsConflictError;
}
interface InstallShapeValidationError_expectedDefaultNotEqualToActualDefault {
    type: "expectedDefaultNotEqualToActualDefault";
    expectedDefaultNotEqualToActualDefault: ExpectedDefaultNotEqualToActualDefault;
}
interface InstallShapeValidationError_expectedDefaultNotEqualToActualDefaultV2 {
    type: "expectedDefaultNotEqualToActualDefaultV2";
    expectedDefaultNotEqualToActualDefaultV2: ExpectedDefaultNotEqualToActualDefaultV2;
}
interface InstallShapeValidationError_externalRecommendationsUsedForInputShapeWithMandatoryPresets {
    type: "externalRecommendationsUsedForInputShapeWithMandatoryPresets";
    externalRecommendationsUsedForInputShapeWithMandatoryPresets: ExternalRecommendationUsedForInputShapeWithMandatoryPresets;
}
interface InstallShapeValidationError_filesDatasourceTypeNotSupported {
    type: "filesDatasourceTypeNotSupported";
    filesDatasourceTypeNotSupported: FilesDatasourceTypeNotSupported;
}
interface InstallShapeValidationError_flinkProfileNotFound {
    type: "flinkProfileNotFound";
    flinkProfileNotFound: BlockInstallFlinkProfileNotFound;
}
interface InstallShapeValidationError_folderInputNotSetToInstallationFolder {
    type: "folderInputNotSetToInstallationFolder";
    folderInputNotSetToInstallationFolder: FolderInputNotSetToInstallationFolder;
}
interface InstallShapeValidationError_folderInputExternallyRecommended {
    type: "folderInputExternallyRecommended";
    folderInputExternallyRecommended: FolderInputExternallyRecommended;
}
interface InstallShapeValidationError_folderInputRequiresInstallingIntoExistingFolder {
    type: "folderInputRequiresInstallingIntoExistingFolder";
    folderInputRequiresInstallingIntoExistingFolder: FolderInputRequiresInstallingIntoExistingFolder;
}
interface InstallShapeValidationError_functionNotFound {
    type: "functionNotFound";
    functionNotFound: BlockInstallFunctionNotFound;
}
interface InstallShapeValidationError_functionShapeError {
    type: "functionShapeError";
    functionShapeError: BlockInstallFunctionShapeError;
}
interface InstallShapeValidationError_functionShapeErrorV2 {
    type: "functionShapeErrorV2";
    functionShapeErrorV2: BlockInstallFunctionShapeErrorV2;
}
interface InstallShapeValidationError_genericDiffServiceValidationError {
    type: "genericDiffServiceValidationError";
    genericDiffServiceValidationError: GenericDiffBlockInstallServiceValidationError;
}
interface InstallShapeValidationError_genericServiceValidationError {
    type: "genericServiceValidationError";
    genericServiceValidationError: GenericBlockInstallServiceValidationError;
}
interface InstallShapeValidationError_incompatibleSemverBlocking {
    type: "incompatibleSemverBlocking";
    incompatibleSemverBlocking: IncompatibleSemverError;
}
interface InstallShapeValidationError_incompatibleSemverNonBlocking {
    type: "incompatibleSemverNonBlocking";
    incompatibleSemverNonBlocking: IncompatibleSemverError;
}
interface InstallShapeValidationError_inputActionTypeNotFound {
    type: "inputActionTypeNotFound";
    inputActionTypeNotFound: BlockInstallInputActionTypeNotFound;
}
interface InstallShapeValidationError_inputShapeTypeMismatch {
    type: "inputShapeTypeMismatch";
    inputShapeTypeMismatch: BlockInstallInputShapeTypeMismatch;
}
interface InstallShapeValidationError_inputShapeNotSpecified {
    type: "inputShapeNotSpecified";
    inputShapeNotSpecified: BlockInstallInputShapeNotSpecified;
}
interface InstallShapeValidationError_installPrefixShapeError {
    type: "installPrefixShapeError";
    installPrefixShapeError: BlockInstallPrefixShapeError;
}
interface InstallShapeValidationError_interfaceTypeNotFound {
    type: "interfaceTypeNotFound";
    interfaceTypeNotFound: BlockInstallInterfaceTypeNotFound;
}
interface InstallShapeValidationError_interfaceTypeMissingProperties {
    type: "interfaceTypeMissingProperties";
    interfaceTypeMissingProperties: BlockInstallInterfaceTypeMissingProperties;
}
interface InstallShapeValidationError_interfaceTypeMissingLinks {
    type: "interfaceTypeMissingLinks";
    interfaceTypeMissingLinks: BlockInstallInterfaceTypeMissingLinks;
}
interface InstallShapeValidationError_interfaceTypeMissingActionTypeConstraints {
    type: "interfaceTypeMissingActionTypeConstraints";
    interfaceTypeMissingActionTypeConstraints: BlockInstallInterfaceTypeMissingActionTypeConstraints;
}
interface InstallShapeValidationError_interfaceTypeMissingExtendedInterfaces {
    type: "interfaceTypeMissingExtendedInterfaces";
    interfaceTypeMissingExtendedInterfaces: BlockInstallInterfaceTypeMissingExtendedInterfaces;
}
interface InstallShapeValidationError_interfaceLinkTypeNotFound {
    type: "interfaceLinkTypeNotFound";
    interfaceLinkTypeNotFound: BlockInstallInterfaceLinkTypeNotFound;
}
interface InstallShapeValidationError_interfaceLinkTypeShapeError {
    type: "interfaceLinkTypeShapeError";
    interfaceLinkTypeShapeError: BlockInstallInterfaceLinkTypeShapeError;
}
interface InstallShapeValidationError_interfacePropertyTypeNotFound {
    type: "interfacePropertyTypeNotFound";
    interfacePropertyTypeNotFound: BlockInstallInterfacePropertyTypeNotFound;
}
interface InstallShapeValidationError_interfacePropertyTypeShapeError {
    type: "interfacePropertyTypeShapeError";
    interfacePropertyTypeShapeError: BlockInstallInterfacePropertyTypeShapeError;
}
interface InstallShapeValidationError_interfaceActionTypeConstraintMissingParameterConstraints {
    type: "interfaceActionTypeConstraintMissingParameterConstraints";
    interfaceActionTypeConstraintMissingParameterConstraints: BlockInstallInterfaceActionTypeConstraintMissingParameterConstraints;
}
interface InstallShapeValidationError_interfaceActionTypeConstraintNotFound {
    type: "interfaceActionTypeConstraintNotFound";
    interfaceActionTypeConstraintNotFound: BlockInstallInterfaceActionTypeConstraintNotFound;
}
interface InstallShapeValidationError_interfaceActionTypeConstraintShapeError {
    type: "interfaceActionTypeConstraintShapeError";
    interfaceActionTypeConstraintShapeError: BlockInstallInterfaceActionTypeConstraintShapeError;
}
interface InstallShapeValidationError_interfaceParameterConstraintNotFound {
    type: "interfaceParameterConstraintNotFound";
    interfaceParameterConstraintNotFound: BlockInstallInterfaceParameterConstraintNotFound;
}
interface InstallShapeValidationError_interfaceParameterConstraintShapeError {
    type: "interfaceParameterConstraintShapeError";
    interfaceParameterConstraintShapeError: BlockInstallInterfaceParameterConstraintShapeError;
}
interface InstallShapeValidationError_inputDownstreamOfOutputsInJobSpecGraph {
    type: "inputDownstreamOfOutputsInJobSpecGraph";
    inputDownstreamOfOutputsInJobSpecGraph: InputDownstreamOfOutputsInJobSpecGraph;
}
interface InstallShapeValidationError_invalidCronExpression {
    type: "invalidCronExpression";
    invalidCronExpression: InvalidCronExpression;
}
interface InstallShapeValidationError_invalidZoneId {
    type: "invalidZoneId";
    invalidZoneId: InvalidZoneId;
}
interface InstallShapeValidationError_linkTypeNotFound {
    type: "linkTypeNotFound";
    linkTypeNotFound: BlockInstallLinkTypeNotFound;
}
interface InstallShapeValidationError_linkTypeShapeError {
    type: "linkTypeShapeError";
    linkTypeShapeError: BlockInstallLinkTypeShapeError;
}
interface InstallShapeValidationError_magritteSourceNotFound {
    type: "magritteSourceNotFound";
    magritteSourceNotFound: BlockInstallMagritteSourceNotFound;
}
interface InstallShapeValidationError_magritteSourceTypeMismatch {
    type: "magritteSourceTypeMismatch";
    magritteSourceTypeMismatch: BlockInstallMagritteSourceTypeMismatch;
}
interface InstallShapeValidationError_magritteSourceMissingRequiredSecrets {
    type: "magritteSourceMissingRequiredSecrets";
    magritteSourceMissingRequiredSecrets: BlockInstallMagritteSourceMissingRequiredSecrets;
}
interface InstallShapeValidationError_magritteSourceMissingRequiredUsageRestrictions {
    type: "magritteSourceMissingRequiredUsageRestrictions";
    magritteSourceMissingRequiredUsageRestrictions: BlockInstallMagritteSourceMissingRequiredUsageRestrictions;
}
interface InstallShapeValidationError_magritteSourceApiNameMismatch {
    type: "magritteSourceApiNameMismatch";
    magritteSourceApiNameMismatch: BlockInstallMagritteSourceApiNameMismatch;
}
interface InstallShapeValidationError_mandatoryPresetNotUsed {
    type: "mandatoryPresetNotUsed";
    mandatoryPresetNotUsed: MandatoryPresetNotUsed;
}
interface InstallShapeValidationError_mediaSetNotSupported {
    type: "mediaSetNotSupported";
    mediaSetNotSupported: BlockInstallMediaSetNotSupported;
}
interface InstallShapeValidationError_mediaSetIncompatiblePathPolicy {
    type: "mediaSetIncompatiblePathPolicy";
    mediaSetIncompatiblePathPolicy: BlockInstallMediaSetIncompatiblePathPolicy;
}
interface InstallShapeValidationError_mediaSetIncompatibleTransactionPolicy {
    type: "mediaSetIncompatibleTransactionPolicy";
    mediaSetIncompatibleTransactionPolicy: BlockInstallMediaSetIncompatibleTransactionPolicy;
}
interface InstallShapeValidationError_mediaSetIncompatibleSchema {
    type: "mediaSetIncompatibleSchema";
    mediaSetIncompatibleSchema: BlockInstallMediaSetIncompatibleSchema;
}
interface InstallShapeValidationError_mediaSetIncompatibleSchemaV2 {
    type: "mediaSetIncompatibleSchemaV2";
    mediaSetIncompatibleSchemaV2: BlockInstallMediaSetIncompatibleSchemaV2;
}
interface InstallShapeValidationError_modelResourceShapeError {
    type: "modelResourceShapeError";
    modelResourceShapeError: BlockInstallModelShapeError;
}
interface InstallShapeValidationError_notepadTemplateNotFound {
    type: "notepadTemplateNotFound";
    notepadTemplateNotFound: BlockInstallNotepadTemplateNotFound;
}
interface InstallShapeValidationError_notepadTemplateParameterNotFound {
    type: "notepadTemplateParameterNotFound";
    notepadTemplateParameterNotFound: BlockInstallNotepadTemplateParameterNotFound;
}
interface InstallShapeValidationError_notepadTemplateParameterShapeError {
    type: "notepadTemplateParameterShapeError";
    notepadTemplateParameterShapeError: BlockInstallNotepadTemplateParameterShapeError;
}
interface InstallShapeValidationError_objectTypeForObjectViewNotFound {
    type: "objectTypeForObjectViewNotFound";
    objectTypeForObjectViewNotFound: BlockInstallObjectTypeForObjectViewNotFound;
}
interface InstallShapeValidationError_objectTypeNotFound {
    type: "objectTypeNotFound";
    objectTypeNotFound: BlockInstallObjectTypeNotFound;
}
interface InstallShapeValidationError_objectTypeShapeError {
    type: "objectTypeShapeError";
    objectTypeShapeError: BlockInstallObjectTypeShapeError;
}
interface InstallShapeValidationError_omittedShapeForShapeWithPresets {
    type: "omittedShapeForShapeWithPresets";
    omittedShapeForShapeWithPresets: OmittedShapeForShapeWithPresets;
}
interface InstallShapeValidationError_ontologyDatasourceMissingFromEntity {
    type: "ontologyDatasourceMissingFromEntity";
    ontologyDatasourceMissingFromEntity: OntologyDatasourceMissingFromEntity;
}
interface InstallShapeValidationError_ontologyEntityNotInTargetOntology {
    type: "ontologyEntityNotInTargetOntology";
    ontologyEntityNotInTargetOntology: OntologyEntityNotInTargetOntology;
}
interface InstallShapeValidationError_ontologyInstallLocationNotDefined {
    type: "ontologyInstallLocationNotDefined";
    ontologyInstallLocationNotDefined: OntologyInstallLocationNotDefined;
}
interface InstallShapeValidationError_outputOwnedByAnotherInstallation {
    type: "outputOwnedByAnotherInstallation";
    outputOwnedByAnotherInstallation: OutputOwnedByAnotherInstallation;
}
interface InstallShapeValidationError_outputShapeTypeMismatch {
    type: "outputShapeTypeMismatch";
    outputShapeTypeMismatch: BlockInstallOutputShapeTypeMismatch;
}
interface InstallShapeValidationError_parameterTypeMismatch {
    type: "parameterTypeMismatch";
    parameterTypeMismatch: BlockInstallInputParameterTypeMismatch;
}
interface InstallShapeValidationError_peerProfileRemoteStrategyMismatch {
    type: "peerProfileRemoteStrategyMismatch";
    peerProfileRemoteStrategyMismatch: PeerProfileRemoteStrategyMismatch;
}
interface InstallShapeValidationError_presetResolutionFailedError {
    type: "presetResolutionFailedError";
    presetResolutionFailedError: PresetResolutionFailedError;
}
interface InstallShapeValidationError_propertyTypeNotFound {
    type: "propertyTypeNotFound";
    propertyTypeNotFound: BlockInstallPropertyTypeNotFound;
}
interface InstallShapeValidationError_propertyTypeShapeError {
    type: "propertyTypeShapeError";
    propertyTypeShapeError: BlockInstallPropertyTypeShapeError;
}
interface InstallShapeValidationError_sharedPropertyTypeNotFound {
    type: "sharedPropertyTypeNotFound";
    sharedPropertyTypeNotFound: BlockInstallSharedPropertyTypeNotFound;
}
interface InstallShapeValidationError_sharedPropertyTypeShapeError {
    type: "sharedPropertyTypeShapeError";
    sharedPropertyTypeShapeError: BlockInstallSharedPropertyTypeShapeError;
}
interface InstallShapeValidationError_sparkProfile {
    type: "sparkProfile";
    sparkProfile: SparkProfileConstraintViolated;
}
interface InstallShapeValidationError_sparkProfileFamilyMismatch {
    type: "sparkProfileFamilyMismatch";
    sparkProfileFamilyMismatch: SparkProfileFamilyMismatch;
}
interface InstallShapeValidationError_stringParameterMaxLengthExceeded {
    type: "stringParameterMaxLengthExceeded";
    stringParameterMaxLengthExceeded: BlockInstallStringParameterMaxLengthExceeded;
}
interface InstallShapeValidationError_resolvedOutputShapeAttachedMultipleTimes {
    type: "resolvedOutputShapeAttachedMultipleTimes";
    resolvedOutputShapeAttachedMultipleTimes: ResolvedOutputShapeAttachedMultipleTimes;
}
interface InstallShapeValidationError_resourceNotFound {
    type: "resourceNotFound";
    resourceNotFound: BlockInstallResourceNotFound;
}
interface InstallShapeValidationError_resourceIsNotChildOfTargetCompassFolder {
    type: "resourceIsNotChildOfTargetCompassFolder";
    resourceIsNotChildOfTargetCompassFolder: BlockInstallResourceNotChildOfTargetCompassFolder;
}
interface InstallShapeValidationError_markingNotFound {
    type: "markingNotFound";
    markingNotFound: MarkingNotFound;
}
interface InstallShapeValidationError_markingTypeNotValid {
    type: "markingTypeNotValid";
    markingTypeNotValid: MarkingTypeNotValid;
}
interface InstallShapeValidationError_markingTypeNotValidV2 {
    type: "markingTypeNotValidV2";
    markingTypeNotValidV2: MarkingTypeNotValidV2;
}
interface InstallShapeValidationError_markingTypeNotValidV3 {
    type: "markingTypeNotValidV3";
    markingTypeNotValidV3: MarkingTypeNotValidV3;
}
interface InstallShapeValidationError_markingSizeConstraintsNotSatisfied {
    type: "markingSizeConstraintsNotSatisfied";
    markingSizeConstraintsNotSatisfied: MarkingSizeConstraintsNotSatisfied;
}
interface InstallShapeValidationError_scheduleShapeInvalid {
    type: "scheduleShapeInvalid";
    scheduleShapeInvalid: ScheduleShapeInvalid;
}
interface InstallShapeValidationError_serializable {
    type: "serializable";
    serializable: MarketplaceSerializableError;
}
interface InstallShapeValidationError_tabularDatasourceShapeError {
    type: "tabularDatasourceShapeError";
    tabularDatasourceShapeError: BlockInstallTabularDatasourceShapeError;
}
interface InstallShapeValidationError_typedBlockInstallServiceValidationError {
    type: "typedBlockInstallServiceValidationError";
    typedBlockInstallServiceValidationError: TypedBlockInstallServiceValidationError;
}
interface InstallShapeValidationError_valueTypeShapeValidationError {
    type: "valueTypeShapeValidationError";
    valueTypeShapeValidationError: ValueTypeShapeValidationError;
}
interface InstallShapeValidationError_versionMismatch {
    type: "versionMismatch";
    versionMismatch: StringMismatchError;
}
interface InstallShapeValidationError_versionedObjectSetNotLatest {
    type: "versionedObjectSetNotLatest";
    versionedObjectSetNotLatest: VersionedObjectSetNotLatestError;
}
type InstallShapeValidationError = InstallShapeValidationError_apiNameMismatch | InstallShapeValidationError_actionParameterShapeErrors | InstallShapeValidationError_actionTypeParameterNotFound | InstallShapeValidationError_actionTypeParameterShapeErrorV2 | InstallShapeValidationError_actionTypeWithNestedParameters | InstallShapeValidationError_attachedOutputCreatedInAnotherInstallation | InstallShapeValidationError_attachedOutputShapeNotSpecified | InstallShapeValidationError_attachNotSupported | InstallShapeValidationError_authoringLibraryNotFound | InstallShapeValidationError_blobsterResourceShapeError | InstallShapeValidationError_cipherChannelAlgorithmMismatch | InstallShapeValidationError_cipherLicenseAlgorithmMismatch | InstallShapeValidationError_cipherLicenseMissingRequiredOperations | InstallShapeValidationError_cipherLicenseMissingRequiredPermits | InstallShapeValidationError_cipherLicenseTypeMismatch | InstallShapeValidationError_classificationConstraintsNotSatisfied | InstallShapeValidationError_codeWorkspaceImageTypeMismatch | InstallShapeValidationError_credentialHasIncorrectSecretNames | InstallShapeValidationError_compassResourceInTrash | InstallShapeValidationError_compassResourceShapeError | InstallShapeValidationError_connectionNotFound | InstallShapeValidationError_connectionTypeMismatch | InstallShapeValidationError_connectionTypeUnsupported | InstallShapeValidationError_connectionReferenceNotResolved | InstallShapeValidationError_connectionReferenceMismatch | InstallShapeValidationError_columnNotFound | InstallShapeValidationError_columnShapeError | InstallShapeValidationError_defaultRequestedForShapeWithNoDefault | InstallShapeValidationError_defaultResolutionFailedError | InstallShapeValidationError_eddieRemoteAndPeeredDestinationsConflictError | InstallShapeValidationError_expectedDefaultNotEqualToActualDefault | InstallShapeValidationError_expectedDefaultNotEqualToActualDefaultV2 | InstallShapeValidationError_externalRecommendationsUsedForInputShapeWithMandatoryPresets | InstallShapeValidationError_filesDatasourceTypeNotSupported | InstallShapeValidationError_flinkProfileNotFound | InstallShapeValidationError_folderInputNotSetToInstallationFolder | InstallShapeValidationError_folderInputExternallyRecommended | InstallShapeValidationError_folderInputRequiresInstallingIntoExistingFolder | InstallShapeValidationError_functionNotFound | InstallShapeValidationError_functionShapeError | InstallShapeValidationError_functionShapeErrorV2 | InstallShapeValidationError_genericDiffServiceValidationError | InstallShapeValidationError_genericServiceValidationError | InstallShapeValidationError_incompatibleSemverBlocking | InstallShapeValidationError_incompatibleSemverNonBlocking | InstallShapeValidationError_inputActionTypeNotFound | InstallShapeValidationError_inputShapeTypeMismatch | InstallShapeValidationError_inputShapeNotSpecified | InstallShapeValidationError_installPrefixShapeError | InstallShapeValidationError_interfaceTypeNotFound | InstallShapeValidationError_interfaceTypeMissingProperties | InstallShapeValidationError_interfaceTypeMissingLinks | InstallShapeValidationError_interfaceTypeMissingActionTypeConstraints | InstallShapeValidationError_interfaceTypeMissingExtendedInterfaces | InstallShapeValidationError_interfaceLinkTypeNotFound | InstallShapeValidationError_interfaceLinkTypeShapeError | InstallShapeValidationError_interfacePropertyTypeNotFound | InstallShapeValidationError_interfacePropertyTypeShapeError | InstallShapeValidationError_interfaceActionTypeConstraintMissingParameterConstraints | InstallShapeValidationError_interfaceActionTypeConstraintNotFound | InstallShapeValidationError_interfaceActionTypeConstraintShapeError | InstallShapeValidationError_interfaceParameterConstraintNotFound | InstallShapeValidationError_interfaceParameterConstraintShapeError | InstallShapeValidationError_inputDownstreamOfOutputsInJobSpecGraph | InstallShapeValidationError_invalidCronExpression | InstallShapeValidationError_invalidZoneId | InstallShapeValidationError_linkTypeNotFound | InstallShapeValidationError_linkTypeShapeError | InstallShapeValidationError_magritteSourceNotFound | InstallShapeValidationError_magritteSourceTypeMismatch | InstallShapeValidationError_magritteSourceMissingRequiredSecrets | InstallShapeValidationError_magritteSourceMissingRequiredUsageRestrictions | InstallShapeValidationError_magritteSourceApiNameMismatch | InstallShapeValidationError_mandatoryPresetNotUsed | InstallShapeValidationError_mediaSetNotSupported | InstallShapeValidationError_mediaSetIncompatiblePathPolicy | InstallShapeValidationError_mediaSetIncompatibleTransactionPolicy | InstallShapeValidationError_mediaSetIncompatibleSchema | InstallShapeValidationError_mediaSetIncompatibleSchemaV2 | InstallShapeValidationError_modelResourceShapeError | InstallShapeValidationError_notepadTemplateNotFound | InstallShapeValidationError_notepadTemplateParameterNotFound | InstallShapeValidationError_notepadTemplateParameterShapeError | InstallShapeValidationError_objectTypeForObjectViewNotFound | InstallShapeValidationError_objectTypeNotFound | InstallShapeValidationError_objectTypeShapeError | InstallShapeValidationError_omittedShapeForShapeWithPresets | InstallShapeValidationError_ontologyDatasourceMissingFromEntity | InstallShapeValidationError_ontologyEntityNotInTargetOntology | InstallShapeValidationError_ontologyInstallLocationNotDefined | InstallShapeValidationError_outputOwnedByAnotherInstallation | InstallShapeValidationError_outputShapeTypeMismatch | InstallShapeValidationError_parameterTypeMismatch | InstallShapeValidationError_peerProfileRemoteStrategyMismatch | InstallShapeValidationError_presetResolutionFailedError | InstallShapeValidationError_propertyTypeNotFound | InstallShapeValidationError_propertyTypeShapeError | InstallShapeValidationError_sharedPropertyTypeNotFound | InstallShapeValidationError_sharedPropertyTypeShapeError | InstallShapeValidationError_sparkProfile | InstallShapeValidationError_sparkProfileFamilyMismatch | InstallShapeValidationError_stringParameterMaxLengthExceeded | InstallShapeValidationError_resolvedOutputShapeAttachedMultipleTimes | InstallShapeValidationError_resourceNotFound | InstallShapeValidationError_resourceIsNotChildOfTargetCompassFolder | InstallShapeValidationError_markingNotFound | InstallShapeValidationError_markingTypeNotValid | InstallShapeValidationError_markingTypeNotValidV2 | InstallShapeValidationError_markingTypeNotValidV3 | InstallShapeValidationError_markingSizeConstraintsNotSatisfied | InstallShapeValidationError_scheduleShapeInvalid | InstallShapeValidationError_serializable | InstallShapeValidationError_tabularDatasourceShapeError | InstallShapeValidationError_typedBlockInstallServiceValidationError | InstallShapeValidationError_valueTypeShapeValidationError | InstallShapeValidationError_versionMismatch | InstallShapeValidationError_versionedObjectSetNotLatest;
interface InstallShapeValidationErrors {
    errors: Record<BlockShapeId, Array<InstallShapeValidationError>>;
}
interface InstallShapeValidationErrorV2 {
    blockSetReference: BlockSetReference;
    blockSetShapeId: BlockSetShapeId;
    error: InstallBlockSetShapeValidationError;
    severity: ErrorSeverity;
}
/**
 * Similar to InstallShapeValidationErrorV2 but applies to a set of block set shape IDs rather than a single
 * one, grouping errors that share the same block set reference, error, and severity.
 */
interface InstallShapeValidationErrorV3 {
    blockSetReference: BlockSetReference;
    blockSetShapeIds: Array<BlockSetShapeId>;
    error: InstallBlockSetShapeValidationError;
    severity: ErrorSeverity;
}
interface InstallValidationError {
    blockReference: BlockReference;
    error: InstallValidationErrorDetail;
}
interface InstallValidationErrorDetail_associatedWithMultipleBlockSetInstallations {
    type: "associatedWithMultipleBlockSetInstallations";
    associatedWithMultipleBlockSetInstallations: AssociatedWithMultipleBlockSetInstallations;
}
interface InstallValidationErrorDetail_attachResourceValidationErrors {
    type: "attachResourceValidationErrors";
    attachResourceValidationErrors: AttachResourceValidationErrors;
}
interface InstallValidationErrorDetail_blockVersionIdDoesNotExist {
    type: "blockVersionIdDoesNotExist";
    blockVersionIdDoesNotExist: BlockVersionIdDoesNotExist;
}
interface InstallValidationErrorDetail_cannotUpgradeToDifferentBlockId {
    type: "cannotUpgradeToDifferentBlockId";
    cannotUpgradeToDifferentBlockId: CannotUpgradeToDifferentBlockId;
}
interface InstallValidationErrorDetail_externalServiceError {
    type: "externalServiceError";
    externalServiceError: ExternalServiceError;
}
interface InstallValidationErrorDetail_inputGroupValidationErrors {
    type: "inputGroupValidationErrors";
    inputGroupValidationErrors: InputGroupValidationErrors;
}
interface InstallValidationErrorDetail_inputShapeNotSpecified {
    type: "inputShapeNotSpecified";
    inputShapeNotSpecified: InputShapeNotSpecified;
}
interface InstallValidationErrorDetail_integrationValidationError {
    type: "integrationValidationError";
    integrationValidationError: TypedBlockInstallServiceValidationError;
}
interface InstallValidationErrorDetail_invalidBlockInstallationReference {
    type: "invalidBlockInstallationReference";
    invalidBlockInstallationReference: InvalidBlockInstallationReference;
}
interface InstallValidationErrorDetail_invalidNewInstallReference {
    type: "invalidNewInstallReference";
    invalidNewInstallReference: InvalidNewInstallReference;
}
interface InstallValidationErrorDetail_multipleInstallInstructionsWithSameKey {
    type: "multipleInstallInstructionsWithSameKey";
    multipleInstallInstructionsWithSameKey: Void;
}
interface InstallValidationErrorDetail_notAssociatedWithAnyBlockSetInstallation {
    type: "notAssociatedWithAnyBlockSetInstallation";
    notAssociatedWithAnyBlockSetInstallation: Void;
}
interface InstallValidationErrorDetail_ontologyInstallLocationNotDefined {
    type: "ontologyInstallLocationNotDefined";
    ontologyInstallLocationNotDefined: OntologyInstallLocationNotDefined;
}
interface InstallValidationErrorDetail_outputShapeOverrideNotSupported {
    type: "outputShapeOverrideNotSupported";
    outputShapeOverrideNotSupported: OutputShapeOverrideNotSupported;
}
interface InstallValidationErrorDetail_resourceUsedAsBothInputAndOutput {
    type: "resourceUsedAsBothInputAndOutput";
    resourceUsedAsBothInputAndOutput: ResourceUsedAsBothInputAndOutput;
}
interface InstallValidationErrorDetail_serializable {
    type: "serializable";
    serializable: MarketplaceSerializableError;
}
interface InstallValidationErrorDetail_shapeDoesNotExistOnBlock {
    type: "shapeDoesNotExistOnBlock";
    shapeDoesNotExistOnBlock: ShapeDoesNotExistOnBlock;
}
interface InstallValidationErrorDetail_shapeValidationErrors {
    type: "shapeValidationErrors";
    shapeValidationErrors: InstallShapeValidationErrors;
}
interface InstallValidationErrorDetail_newInstallationOfASingletonBlockSetThatIsAlreadyInstalled {
    type: "newInstallationOfASingletonBlockSetThatIsAlreadyInstalled";
    newInstallationOfASingletonBlockSetThatIsAlreadyInstalled: NewInstallationOfSingletonBlockSetThatIsAlreadyInstalled;
}
interface InstallValidationErrorDetail_upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes {
    type: "upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes";
    upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes: UpgradeOfSingletonBlockSetThatIsInstalledMultipleTimes;
}
type InstallValidationErrorDetail = InstallValidationErrorDetail_associatedWithMultipleBlockSetInstallations | InstallValidationErrorDetail_attachResourceValidationErrors | InstallValidationErrorDetail_blockVersionIdDoesNotExist | InstallValidationErrorDetail_cannotUpgradeToDifferentBlockId | InstallValidationErrorDetail_externalServiceError | InstallValidationErrorDetail_inputGroupValidationErrors | InstallValidationErrorDetail_inputShapeNotSpecified | InstallValidationErrorDetail_integrationValidationError | InstallValidationErrorDetail_invalidBlockInstallationReference | InstallValidationErrorDetail_invalidNewInstallReference | InstallValidationErrorDetail_multipleInstallInstructionsWithSameKey | InstallValidationErrorDetail_notAssociatedWithAnyBlockSetInstallation | InstallValidationErrorDetail_ontologyInstallLocationNotDefined | InstallValidationErrorDetail_outputShapeOverrideNotSupported | InstallValidationErrorDetail_resourceUsedAsBothInputAndOutput | InstallValidationErrorDetail_serializable | InstallValidationErrorDetail_shapeDoesNotExistOnBlock | InstallValidationErrorDetail_shapeValidationErrors | InstallValidationErrorDetail_newInstallationOfASingletonBlockSetThatIsAlreadyInstalled | InstallValidationErrorDetail_upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes;
interface InsufficientPermissionsError {
    error: InsufficientPermissionsErrorUnion;
}
interface InsufficientPermissionsErrorUnion_missingOperation {
    type: "missingOperation";
    missingOperation: MissingOperationError;
}
interface InsufficientPermissionsErrorUnion_notAuthorizedToDeclassify {
    type: "notAuthorizedToDeclassify";
    notAuthorizedToDeclassify: NotAuthorizedToUseMarkingsError;
}
interface InsufficientPermissionsErrorUnion_notAuthorizedToUseMarkings {
    type: "notAuthorizedToUseMarkings";
    notAuthorizedToUseMarkings: NotAuthorizedToDeclassifyError;
}
interface InsufficientPermissionsErrorUnion_notAuthorizedToDeclassifyV2 {
    type: "notAuthorizedToDeclassifyV2";
    notAuthorizedToDeclassifyV2: NotAuthorizedToDeclassifyError;
}
interface InsufficientPermissionsErrorUnion_notAuthorizedToUseMarkingsV2 {
    type: "notAuthorizedToUseMarkingsV2";
    notAuthorizedToUseMarkingsV2: NotAuthorizedToUseMarkingsErrorV2;
}
interface InsufficientPermissionsErrorUnion_generic {
    type: "generic";
    generic: GenericCreateBlockVersionError;
}
type InsufficientPermissionsErrorUnion = InsufficientPermissionsErrorUnion_missingOperation | InsufficientPermissionsErrorUnion_notAuthorizedToDeclassify | InsufficientPermissionsErrorUnion_notAuthorizedToUseMarkings | InsufficientPermissionsErrorUnion_notAuthorizedToDeclassifyV2 | InsufficientPermissionsErrorUnion_notAuthorizedToUseMarkingsV2 | InsufficientPermissionsErrorUnion_generic;
/**
 * IntegerListType specifies that this parameter must be a list of Integers.
 */
interface IntegerListType {
}
/**
 * IntegerType specifies that this parameter must be an Integer.
 */
interface IntegerType {
}
type IntegerValue = number;
type IntegerVersion = number;
interface IntegrationCreateBlockVersionError_unknownError {
    type: "unknownError";
    unknownError: UnknownMarketplaceCreateBlockVersionError;
}
/**
 * This is an error that is used as a placeholder for integrations that haven't defined their own error union
 * types yet.
 */
type IntegrationCreateBlockVersionError = IntegrationCreateBlockVersionError_unknownError;
type InterfaceActionTypeConstraintApiName = string;
interface InterfaceActionTypeConstraintIdentifier_rid {
    type: "rid";
    rid: InterfaceActionTypeConstraintRidIdentifier;
}
type InterfaceActionTypeConstraintIdentifier = InterfaceActionTypeConstraintIdentifier_rid;
interface InterfaceActionTypeConstraintNotFound {
    interfaceActionTypeConstraintRid?: InterfaceActionTypeConstraintRid | null | undefined;
}
type InterfaceActionTypeConstraintReference = BlockInternalId;
interface InterfaceActionTypeConstraintReferenceUnresolvable {
    actual: InterfaceActionTypeConstraintRid;
    expected: InterfaceActionTypeConstraintReference;
    interfaceTypeRid: InterfaceTypeRid;
}
interface InterfaceActionTypeConstraintRequiredMismatch {
    actual: boolean;
    expected: boolean;
    interfaceActionTypeConstraintRid: InterfaceActionTypeConstraintRid;
    interfaceTypeRid: InterfaceTypeRid;
}
type InterfaceActionTypeConstraintRid = string;
interface InterfaceActionTypeConstraintRidIdentifier {
    interfaceTypeRid: InterfaceTypeRid;
    rid: InterfaceActionTypeConstraintRid;
}
interface InterfaceActionTypeConstraintShape {
    about: LocalizedTitleAndDescription;
    interfaceType: InterfaceTypeReference;
    parameterConstraints: Array<InterfaceParameterConstraintReference>;
    requireImplementation: boolean;
}
type InterfaceLinkTypeApiName = string;
type InterfaceLinkTypeCardinality = "SINGLE" | "MANY";
interface InterfaceLinkTypeCardinalityMismatch {
    actual: InterfaceLinkTypeCardinality;
    expected: InterfaceLinkTypeCardinality;
}
interface InterfaceLinkTypeIdentifier {
    interfaceLinkTypeKey: InterfaceLinkTypeRid;
    interfaceTypeIdentifier: InterfaceTypeIdentifier;
}
interface InterfaceLinkTypeInputShape {
    about: LocalizedTitleAndDescription;
    cardinality: InterfaceLinkTypeCardinality;
    interfaceType: InterfaceTypeReference;
    linkedEntityType: LinkedEntityTypeReference;
    required: boolean;
}
interface InterfaceLinkTypeNotFound {
    interfaceLinkTypeRid?: InterfaceLinkTypeRid | null | undefined;
}
interface InterfaceLinkTypeOutputShape {
    about: LocalizedTitleAndDescription;
    cardinality: InterfaceLinkTypeCardinality;
    interfaceType: InterfaceTypeReference;
    linkedEntityType: LinkedEntityTypeReference;
    required: boolean;
}
type InterfaceLinkTypeReference = BlockInternalId;
interface InterfaceLinkTypeRequiredMismatch {
    actual: boolean;
    expected: boolean;
}
type InterfaceLinkTypeRid = string;
/**
 * InterfaceObjectSetRidType specifies that this parameter must be an ObjectSetRid of ObjectTypes implementing
 * the specified interface type.
 */
interface InterfaceObjectSetRidType {
    interfaceTypeRid: InterfaceTypeReference;
}
interface InterfaceParameterConstraintIdentifier_rid {
    type: "rid";
    rid: InterfaceParameterConstraintRidIdentifier;
}
type InterfaceParameterConstraintIdentifier = InterfaceParameterConstraintIdentifier_rid;
type InterfaceParameterConstraintReference = BlockInternalId;
interface InterfaceParameterConstraintRequiredMismatch {
    actual: boolean;
    expected: boolean;
    interfaceActionTypeConstraintRid: InterfaceActionTypeConstraintRid;
    interfaceParameterConstraintRid: InterfaceParameterConstraintRid;
    interfaceTypeRid: InterfaceTypeRid;
}
type InterfaceParameterConstraintRid = string;
interface InterfaceParameterConstraintRidIdentifier {
    actionTypeConstraintRid: InterfaceActionTypeConstraintRid;
    interfaceTypeRid: InterfaceTypeRid;
    rid: InterfaceParameterConstraintRid;
}
interface InterfaceParameterConstraintShape {
    about: LocalizedTitleAndDescription;
    actionTypeConstraint: InterfaceActionTypeConstraintReference;
    requireImplementation: boolean;
    type: BaseParameterConstraintType;
}
/**
 * The parameter constraint type doesn't match the type in the ontology definition.
 */
interface InterfaceParameterConstraintTypeMismatch {
    actual: string;
    expected: string;
    interfaceActionTypeConstraintRid: InterfaceActionTypeConstraintRid;
    interfaceParameterConstraintRid: InterfaceParameterConstraintRid;
    interfaceTypeRid: InterfaceTypeRid;
}
interface InterfaceParameterPropertyValue {
    parameterId: ActionTypeParameterReference;
    sharedPropertyTypeRid: SharedPropertyTypeReference;
}
/**
 * When supplying an interface property, which is backed by an SPT, as input, that interface property has to
 * be backed by the same SPT that is used to fulfill the input shape created for the SPT itself.
 */
interface InterfacePropertySharedPropertyTypeReferenceMismatch {
    expectedSharedPropertyTypeReference?: SharedPropertyTypeReference | null | undefined;
    expectedSharedPropertyTypeRid?: SharedPropertyTypeRid | null | undefined;
    inputSharedPropertyTypeReference?: SharedPropertyTypeReference | null | undefined;
    inputSharedPropertyTypeRid?: SharedPropertyTypeRid | null | undefined;
}
type InterfacePropertyTypeApiName = string;
interface InterfacePropertyTypeIdentifier {
    interfacePropertyTypeKey: InterfacePropertyTypeRid;
    interfaceTypeIdentifier: InterfaceTypeIdentifier;
}
interface InterfacePropertyTypeInputShape {
    about: LocalizedTitleAndDescription;
    interfaceType: InterfaceTypeReference;
    requireImplementation: boolean;
    sharedPropertyType?: SharedPropertyTypeReference | null | undefined;
    type: AllowedObjectPropertyType;
}
interface InterfacePropertyTypeNotFound {
    interfacePropertyTypeRid?: InterfacePropertyTypeRid | null | undefined;
}
interface InterfacePropertyTypeOutputShape {
    about: LocalizedTitleAndDescription;
    dataConstraints?: DataConstraints | null | undefined;
    interfaceType: InterfaceTypeReference;
    requireImplementation: boolean;
    sharedPropertyType?: SharedPropertyTypeReference | null | undefined;
    type: ObjectPropertyType;
}
type InterfacePropertyTypeReference = BlockInternalId;
interface InterfacePropertyTypeRequireImplementationMismatch {
    actual: boolean;
    expected: boolean;
}
type InterfacePropertyTypeRid = string;
interface InterfaceReferenceListType {
    interfaceTypeRid: InterfaceTypeReference;
}
interface InterfaceReferenceType {
    interfaceTypeRid: InterfaceTypeReference;
}
type InterfaceTypeApiName = string;
interface InterfaceTypeIdentifier_rid {
    type: "rid";
    rid: InterfaceTypeRid;
}
type InterfaceTypeIdentifier = InterfaceTypeIdentifier_rid;
interface InterfaceTypeInputShape {
    about: LocalizedTitleAndDescription;
    actionTypeConstraints: Array<InterfaceActionTypeConstraintReference>;
    links: Array<InterfaceLinkTypeReference>;
    properties: Array<SharedPropertyTypeReference>;
    propertiesV2: Array<InterfacePropertyTypeReference>;
}
interface InterfaceTypeOutputShape {
    about: LocalizedTitleAndDescription;
    actionTypeConstraints: Array<InterfaceActionTypeConstraintReference>;
    extendsInterfaces: Array<InterfaceTypeReference>;
    links: Array<InterfaceLinkTypeReference>;
    properties: Array<SharedPropertyTypeReference>;
    propertiesV2: Array<InterfacePropertyTypeReference>;
}
type InterfaceTypeReference = BlockInternalId;
/**
 * An InterfaceTypeRid was referenced for which the shape id could not be resolved. This is typical if the
 * referenced InterfaceType has not been included as an input/output in the block.
 */
interface InterfaceTypeReferenceUnresolvable {
    actual: InterfaceTypeRid;
    expected: InterfaceTypeReference;
}
type InterfaceTypeRid = string;
/**
 * The Shape Id that was resolved for the LinkType does not match the shape id expected.
 */
interface IntermediaryLinkLinkTypeReferenceMismatch {
    mismatchedLinkTypeReference: ResolvedLinkTypeReferenceMismatch;
    side: IntermediaryLinkLinkTypeSide;
}
/**
 * A LinkTypeRid was referenced for which the shape id could not be resolved. This is typical if the
 * referenced LinkType has not been included as an input/output in the block.
 */
interface IntermediaryLinkLinkTypeReferenceUnresolvable {
    side: IntermediaryLinkLinkTypeSide;
    unresolvableLinkReference: LinkTypeReferenceUnresolvable;
}
type IntermediaryLinkLinkTypeSide = "SIDE_A" | "SIDE_B";
/**
 * The Shape Id that was resolved for the ObjectType does not match the shape id expected.
 */
interface IntermediaryLinkObjectTypeMismatch {
    mismatchedObjectTypeReference: ResolvedObjectTypeReferenceMismatch;
    side: IntermediaryLinkObjectTypeSide;
}
/**
 * An ObjectTypeRid was referenced for which the shape id could not be resolved. This is typical if the
 * referenced ObjectType has not been included as an input/output in the block.
 */
interface IntermediaryLinkObjectTypeReferenceUnresolvable {
    side: IntermediaryLinkObjectTypeSide;
    unresolvableObjectReference: ObjectTypeReferenceUnresolvable;
}
type IntermediaryLinkObjectTypeSide = "SIDE_A" | "SIDE_B" | "INTERMEDIARY";
interface IntermediaryLinkTypeApiNames {
    objectTypeAToBApiName: ObjectTypeFieldApiName;
    objectTypeBToAApiName: ObjectTypeFieldApiName;
}
type InternalShapeId = string;
interface InvalidBlockInstallationReference {
    blockInstallationRid: BlockInstallationRid;
}
/**
 * The `AssociatedBlockSetInstallation` is referencing a block install which doesn't exist in the
 * set of install instructions provided in the request.
 */
interface InvalidBlockReference {
    blockReference: BlockReference;
    blockSetBlockInstanceId: BlockSetBlockInstanceId;
}
/**
 * The cron expression is not valid.
 */
interface InvalidCronExpression {
    reason: string;
}
interface InvalidInstallationProject {
    projectRid: CompassProjectRid;
    reasons: Array<InvalidInstallationProjectReason>;
}
type InvalidInstallationProjectReason = "CANNOT_SEE_CONTENTS" | "DOES_NOT_EXIST" | "HAS_AUTOSAVE_RESOURCES" | "HAS_TRASHED_RESOURCES" | "IS_NOT_EMPTY" | "IS_SERVICE_PROJECT" | "IS_TRASHED" | "IS_USER_FOLDER" | "NOT_IN_EXPECTED_NAMESPACE" | "USED_FOR_MULTIPLE_INSTALLATIONS";
/**
 * Corresponds to the ValidateInstallBlockSetsResponse, but is guaranteed to contain at least 1 error across
 * all fields
 */
type InvalidInstallBlockSetsRequest = ValidateInstallBlockSetsResponse;
interface InvalidInstallBlocksRequest {
    blockSetValidationErrors: Array<BlockSetInstallValidationError>;
    validationErrors: Array<InstallValidationError>;
}
interface InvalidLinkedProduct {
    upstreamBlockSet: BlockSetId;
    upstreamBlockSetInstallation: BlockSetReference;
}
interface InvalidNewBlockSetInstallationReferences {
    invalidReferences: Array<NewBlockSetInstallationId>;
    provided: Array<NewBlockSetInstallationId>;
}
interface InvalidNewInstallReference {
    newInstallId: InstallNewBlockInstructionId;
}
/**
 * The zone id is not valid.
 */
interface InvalidZoneId {
    reason: string;
}
interface IssueRecallRequest {
    blockSetVersions: Array<BlockSetVersionId>;
    message: string;
    rollOffStrategy: RollOffStrategy;
}
interface IssueRecallResponse {
    recallId: RecallId;
}
/**
 * Lightweight metadata for the job draft.
 */
interface JobDraftMetadata {
    createdAt: CreationTimestamp;
    createdByUser: MultipassUserId;
    lastUpdatedAt: LastUpdatedTimestamp;
    rid: BlockSetInstallationJobRid;
    targetInstallations: Array<TargetInstallationSummary>;
}
interface JobDraftOwnerValidationErrors_validationErrors {
    type: "validationErrors";
    validationErrors: JobDraftValidationErrorsV2;
}
interface JobDraftOwnerValidationErrors_validationSummary {
    type: "validationSummary";
    validationSummary: JobDraftValidationErrorSummary;
}
interface JobDraftOwnerValidationErrors_validations {
    type: "validations";
    validations: JobDraftValidationErrors;
}
type JobDraftOwnerValidationErrors = JobDraftOwnerValidationErrors_validationErrors | JobDraftOwnerValidationErrors_validationSummary | JobDraftOwnerValidationErrors_validations;
interface JobDraftStatus_resolving {
    type: "resolving";
    resolving: Void;
}
interface JobDraftStatus_validating {
    type: "validating";
    validating: Void;
}
interface JobDraftStatus_idle {
    type: "idle";
    idle: Void;
}
interface JobDraftStatus_submittingJob {
    type: "submittingJob";
    submittingJob: Void;
}
interface JobDraftStatus_submitted {
    type: "submitted";
    submitted: Void;
}
/**
 * The current status of an installation job draft. Poll `getJobDraftStatus` to track progress.
 */
type JobDraftStatus = JobDraftStatus_resolving | JobDraftStatus_validating | JobDraftStatus_idle | JobDraftStatus_submittingJob | JobDraftStatus_submitted;
interface JobDraftValidationErrors {
    blockSetValidationErrors: Array<BlockSetInstallValidationErrorV2>;
    jobValidationErrors: Array<InstallationJobValidationErrorV2>;
    shapeValidationErrors: Array<InstallShapeValidationErrorV2>;
}
interface JobDraftValidationErrorSummary {
    totalBlockingErrors: number;
}
interface JobDraftValidationErrorsV2 {
    blockSet: Array<BlockSetInstallValidationErrorV2>;
    job: Array<InstallationJobValidationErrorV2>;
    shapes: Array<InstallShapeValidationErrorV3>;
}
type JobRid = string;
interface JobSettings {
    buildSettings?: BuildSettings | null | undefined;
}
/**
 * Used when the repository delivers transforms such as transforms-python or transforms-java
 */
interface JobSpecEnvironmentIdentificationMethod {
    jobSpecRids: Array<string>;
}
interface JobSpecEnvironmentIdentificationMethodV2 {
    jobSpecRid: JobSpecRid;
}
type JobSpecRid = string;
interface JobSubmissionFailure_conflictingJobs {
    type: "conflictingJobs";
    conflictingJobs: Record<BlockSetInstallationRid, InstallBlocksJobRid>;
}
type JobSubmissionFailure = JobSubmissionFailure_conflictingJobs;
interface JobSubmittedResult {
    jobRid: BlockSetInstallationJobRid;
    newBlockSetInstallationRids: Record<NewBlockSetInstallationId, BlockSetInstallationRid>;
}
interface Jpeg2000Format {
}
interface JpgFormat {
}
/**
 * Service-specific identifier used to ensure block internal identifiers stability
 */
type KnownIdentifier = string;
interface LanguageModelIdentifier {
    rid: LanguageModelRid;
    ridForAttribution?: string | null | undefined;
}
type LanguageModelRid = string;
interface LanguageModelShape {
    about: LocalizedTitleAndDescription;
}
interface LasFormat {
}
type LastUpdatedTimestamp = string;
/**
 * Constraint failure for when the last automatic upgrade failed. Requires manual ack to clear
 */
interface LastUpgradeFailedConstraintFailure {
    error: InstallBlocksStatusError;
}
interface LatestVersionPolicy {
}
/**
 * Placeholder identifier for shapes that have not implemented support for shape generation yet. Only here for
 * legacy purposes. DO NOT USE WHEN ADDING A NEW SHAPE.
 */
interface LegacyNotImplementedIdentifier {
}
interface LibraryLocatorEnvironmentIdentificationMethod_condaLocator {
    type: "condaLocator";
    condaLocator: CondaLocator;
}
interface LibraryLocatorEnvironmentIdentificationMethod_condaLocatorV2 {
    type: "condaLocatorV2";
    condaLocatorV2: CondaLocatorV2;
}
/**
 * Used when the repository delivers a library. Integrations for this block type need to know the library path
 * in Artifacts in order to download the library for packaging.
 */
type LibraryLocatorEnvironmentIdentificationMethod = LibraryLocatorEnvironmentIdentificationMethod_condaLocator | LibraryLocatorEnvironmentIdentificationMethod_condaLocatorV2;
/**
 * Represents the type of product the license supports.
 */
type LicenseProductType = "RSTUDIO";
interface LinkedEntityTypeReference_objectType {
    type: "objectType";
    objectType: ObjectTypeReference;
}
interface LinkedEntityTypeReference_interfaceType {
    type: "interfaceType";
    interfaceType: InterfaceTypeReference;
}
type LinkedEntityTypeReference = LinkedEntityTypeReference_objectType | LinkedEntityTypeReference_interfaceType;
/**
 * Shape id that was resolved for the linked-to InterfaceType does not match the shape id expected.
 */
interface LinkedInterfaceTypeReferenceMismatch {
    actual: InterfaceTypeReference;
    expected: InterfaceTypeReference;
}
/**
 * An InterfaceTypeRid was linked-to for which the shape id could not be resolved. This is typical if the
 * referenced InterfaceType has not been included as an input/output in the block.
 */
interface LinkedInterfaceTypeReferenceUnresolvable {
    actual: InterfaceTypeRid;
    expected: InterfaceTypeReference;
}
/**
 * Shape id that was resolved for the linked-to ObjectType does not match the shape id expected.
 */
interface LinkedObjectTypeReferenceMismatch {
    actual: ObjectTypeReference;
    expected: ObjectTypeReference;
}
/**
 * An ObjectTypeId was linked-to for which the shape id could not be resolved. This is typical if the
 * referenced ObjectType has not been included as an input/output in the block.
 */
interface LinkedObjectTypeReferenceUnresolvable {
    actual: ObjectTypeId;
    expected: ObjectTypeReference;
}
/**
 * A list of additional resources, such as YouTube videos, Palantir documentation, or other external links.
 * These resources supplement the main documentation.
 */
type Links = Array<Url>;
interface LinkTypeApiNames_oneToMany {
    type: "oneToMany";
    oneToMany: OneToManyLinkTypeApiNames;
}
interface LinkTypeApiNames_manyToMany {
    type: "manyToMany";
    manyToMany: ManyToManyLinkTypeApiNames;
}
interface LinkTypeApiNames_intermediary {
    type: "intermediary";
    intermediary: IntermediaryLinkTypeApiNames;
}
type LinkTypeApiNames = LinkTypeApiNames_oneToMany | LinkTypeApiNames_manyToMany | LinkTypeApiNames_intermediary;
type LinkTypeId = string;
interface LinkTypeIdentifier_rid {
    type: "rid";
    rid: LinkTypeRid;
}
interface LinkTypeIdentifier_id {
    type: "id";
    id: LinkTypeId;
}
type LinkTypeIdentifier = LinkTypeIdentifier_rid | LinkTypeIdentifier_id;
interface LinkTypeIdResolver {
    linkTypeIdWithoutOntologyPrefix: string;
}
interface LinkTypeInputShape_oneToMany {
    type: "oneToMany";
    oneToMany: LinkTypeOneToManyShape;
}
interface LinkTypeInputShape_manyToMany {
    type: "manyToMany";
    manyToMany: LinkTypeManyToManyInputShape;
}
interface LinkTypeInputShape_intermediary {
    type: "intermediary";
    intermediary: LinkTypeIntermediaryShape;
}
type LinkTypeInputShape = LinkTypeInputShape_oneToMany | LinkTypeInputShape_manyToMany | LinkTypeInputShape_intermediary;
interface LinkTypeIntermediaryShape {
    about: LocalizedTitleAndDescription;
    aToIntermediaryLinkTypeShapeId: LinkTypeReference;
    intermediaryObjectTypeShapeId: ObjectTypeReference;
    intermediaryToBLinkTypeShapeId: LinkTypeReference;
    objectTypeAShapeId: ObjectTypeReference;
    objectTypeAToBLinkMetadata: LocalizedTitleAndDescription;
    objectTypeBShapeId: ObjectTypeReference;
    objectTypeBToALinkMetadata: LocalizedTitleAndDescription;
}
interface LinkTypeIntermediaryShapeDisplayMetadata {
    about: LocalizedTitleAndDescription;
    objectTypeAToBLinkMetadata: LocalizedTitleAndDescription;
    objectTypeBToALinkMetadata: LocalizedTitleAndDescription;
}
interface LinkTypeManyToManyInputShape {
    about: LocalizedTitleAndDescription;
    editsSupport: InputEditsSupport;
    objectsBackendVersion: InputObjectBackendVersion;
    objectTypeAToBLinkMetadata: LocalizedTitleAndDescription;
    objectTypeBToALinkMetadata: LocalizedTitleAndDescription;
    objectTypeShapeIdA: ObjectTypeReference;
    objectTypeShapeIdB: ObjectTypeReference;
}
interface LinkTypeManyToManyOutputShape {
    about: LocalizedTitleAndDescription;
    editsSupport: OutputEditsSupport;
    objectsBackendVersion: OutputObjectBackendVersion;
    objectTypeAToBLinkMetadata: LocalizedTitleAndDescription;
    objectTypeBToALinkMetadata: LocalizedTitleAndDescription;
    objectTypeShapeIdA: ObjectTypeReference;
    objectTypeShapeIdB: ObjectTypeReference;
}
interface LinkTypeManyToManyShapeDisplayMetadata {
    about: LocalizedTitleAndDescription;
    objectTypeAToBLinkMetadata: LocalizedTitleAndDescription;
    objectTypeBToALinkMetadata: LocalizedTitleAndDescription;
}
interface LinkTypeNotFound {
    linkTypeId?: LinkTypeId | null | undefined;
    linkTypeRid?: LinkTypeRid | null | undefined;
}
interface LinkTypeOneToManyShape {
    about: LocalizedTitleAndDescription;
    cardinalityHint?: OneToManyLinkCardinalityHint | null | undefined;
    manyToOneLinkMetadata: LocalizedTitleAndDescription;
    objectTypeShapeIdManySide: ObjectTypeReference;
    objectTypeShapeIdOneSide: ObjectTypeReference;
    oneToManyLinkMetadata: LocalizedTitleAndDescription;
}
interface LinkTypeOneToManyShapeDisplayMetadata {
    about: LocalizedTitleAndDescription;
    manyToOneLinkMetadata: LocalizedTitleAndDescription;
    oneToManyLinkMetadata: LocalizedTitleAndDescription;
}
interface LinkTypeOutputShape_oneToMany {
    type: "oneToMany";
    oneToMany: LinkTypeOneToManyShape;
}
interface LinkTypeOutputShape_manyToMany {
    type: "manyToMany";
    manyToMany: LinkTypeManyToManyOutputShape;
}
interface LinkTypeOutputShape_intermediary {
    type: "intermediary";
    intermediary: LinkTypeIntermediaryShape;
}
type LinkTypeOutputShape = LinkTypeOutputShape_oneToMany | LinkTypeOutputShape_manyToMany | LinkTypeOutputShape_intermediary;
type LinkTypeReference = BlockInternalId;
/**
 * A LinkTypeRid was referenced for which the shape id could not be resolved. This is typical if the
 * referenced LinkType has not been included as an input/output in the block.
 */
interface LinkTypeReferenceUnresolvable {
    actual: LinkTypeRid;
    expected: LinkTypeReference;
}
type LinkTypeRid = string;
interface LinkTypeShapeDisplayMetadata_oneToMany {
    type: "oneToMany";
    oneToMany: LinkTypeOneToManyShapeDisplayMetadata;
}
interface LinkTypeShapeDisplayMetadata_manyToMany {
    type: "manyToMany";
    manyToMany: LinkTypeManyToManyShapeDisplayMetadata;
}
interface LinkTypeShapeDisplayMetadata_intermediary {
    type: "intermediary";
    intermediary: LinkTypeIntermediaryShapeDisplayMetadata;
}
type LinkTypeShapeDisplayMetadata = LinkTypeShapeDisplayMetadata_oneToMany | LinkTypeShapeDisplayMetadata_manyToMany | LinkTypeShapeDisplayMetadata_intermediary;
type LinkTypeType = "ONE_TO_MANY" | "MANY_TO_MANY" | "INTERMEDIARY";
/**
 * An unexpected LinkType was provided for an input that should be another kind of Link Type as
 * per the shape definition.
 */
interface LinkTypeUnexpected {
    actual: LinkTypeType;
    expected: LinkTypeType;
}
/**
 * An unknown type of LinkType definition was encountered. This indicates we might have run into a new
 * kind of LinkType that isn't yet supported in Marketplace.
 */
interface LinkTypeUnknown {
    unknownType: string;
}
interface ListAvailableInstallLocationsResponse {
    namespaces: Array<NamespaceRid>;
    ontologies: Array<OntologyRid>;
}
interface ListBlockInstallationJobsResponseEntry {
    rid: InstallBlocksJobRid;
}
interface ListBlockInstallationJobsResponseV2 {
    jobs: Array<ListBlockInstallationJobsResponseEntry>;
    nextPageToken?: ListBlockInstallationJobsV2PageToken | null | undefined;
}
type ListBlockInstallationJobsV2PageToken = string;
type ListBlockSetInstallationJobsPageToken = string;
interface ListBlockSetInstallationJobsResponse {
    jobs: Array<BlockSetInstallationJobMetadata>;
    nextPageToken?: ListBlockSetInstallationJobsPageToken | null | undefined;
}
type ListBlockSetInstallationsMetadataPageToken = string;
interface ListBlockSetInstallationsMetadataResponse {
    metadata: Array<BlockSetInstallationMetadata>;
    nextPageToken?: ListBlockSetInstallationsMetadataPageToken | null | undefined;
}
interface ListBlockSetInstallationsResponseV2 {
    blockSets: Array<BlockSetInstallationV2>;
    nextPageToken?: ListBlockSetInstallationsV2PageToken | null | undefined;
}
type ListBlockSetInstallationsV2PageToken = string;
interface ListBlockSetsPageToken {
    creationTimestamp: string;
    id: BlockSetId;
}
interface ListBlockSetsResponse {
    blockSets: Array<ListBlockSetsResponseEntry>;
    nextPageToken?: ListBlockSetsPageToken | null | undefined;
}
interface ListBlockSetsResponseEntry {
    id: BlockSetId;
    latestVersionId?: BlockSetVersionId | null | undefined;
    mavenCoordinateOfLatestVersion?: OrderableMavenCoordinate | null | undefined;
}
type ListBlockSetVersionsPageToken = BlockSetVersion;
interface ListBlockSetVersionsResponse {
    nextPageToken?: ListBlockSetVersionsPageToken | null | undefined;
    versions: Array<BlockSetNamedVersion>;
}
type ListDraftGroupsPageToken = string;
interface ListDraftGroupsResponse {
    groups: Array<DraftGroup>;
    nextPageToken?: ListDraftGroupsPageToken | null | undefined;
}
interface ListInstallableBlockSetVersionsByMavenProductIdResponse {
    blockSetId: BlockSetId;
    nextPageToken?: ListInstallableBlockSetVersionsPageToken | null | undefined;
    versions: Array<BlockSetNamedVersion>;
}
interface ListInstallableBlockSetVersionsPageToken {
    version: BlockSetVersion;
    versionId: BlockSetVersionId;
}
interface ListInstallableBlockSetVersionsRequest {
    pageToken?: ListInstallableBlockSetVersionsPageToken | null | undefined;
}
interface ListInstallableBlockSetVersionsResponse {
    nextPageToken?: ListInstallableBlockSetVersionsPageToken | null | undefined;
    versions: Array<BlockSetNamedVersion>;
}
interface ListJobDraftsForUserResponse {
    drafts: Array<ListJobDraftsForUserResponseEntry>;
    nextPageToken?: ListJobDraftsPageToken | null | undefined;
}
/**
 * Summary of an installation job draft and its installations.
 */
interface ListJobDraftsForUserResponseEntry {
    jobRid: BlockSetInstallationJobRid;
    lastUpdatedAt: LastUpdatedTimestamp;
    targetInstallations: Array<TargetInstallationSummary>;
}
type ListJobDraftsPageToken = string;
type ListPendingBlockSetVersionsPageToken = string;
interface ListPendingBlockSetVersionsResponse {
    blockSets: Array<ListPendingBlockSetVersionsResponseEntry>;
    nextPageToken?: ListPendingBlockSetVersionsPageToken | null | undefined;
}
interface ListPendingBlockSetVersionsResponseEntry {
    id: BlockSetVersionId;
}
type ListProductsPageToken = string;
interface ListProductsReponseEntry {
    id: ProductId;
    latestVersionMetadata: ProductVersionMetadata;
}
interface ListProductsResponse {
    nextPageToken?: ListProductsPageToken | null | undefined;
    products: Array<ListProductsReponseEntry>;
}
type ListProductVersionsPageToken = string;
interface ListProductVersionsResponse {
    nextPageToken?: ListProductVersionsPageToken | null | undefined;
    versions: Array<ProductVersionMetadata>;
}
type ListSnapshotsForProductGroupPageToken = string;
/**
 * Request to list snapshots for a given product group.
 */
interface ListSnapshotsForProductGroupRequest {
    limit?: number | null | undefined;
    pageToken?: ListSnapshotsForProductGroupPageToken | null | undefined;
}
/**
 * Response containing snapshot summaries for a given product group.
 */
interface ListSnapshotsForProductGroupResponse {
    nextPageToken?: ListSnapshotsForProductGroupPageToken | null | undefined;
    productGroupRid: ProductGroupRid;
    snapshotSummaries: Array<ProductGroupSnapshot>;
}
/**
 * A language/locale identifier as per [RFC-5646](https://datatracker.ietf.org/doc/html/rfc5646).
 *
 * When matching, will preferentially match the most specific applicable identifier (e.g. `en-GB`
 * will match to `en` only if `en-GB` isn't available).
 */
type Locale = string;
/**
 * A localized description for the given resource.
 */
type LocalizedDescription = string;
interface LocalizedFreeFormDocumentationSections {
    fallbackFreeFormDocumentation: FreeFormDocumentationSections;
    localizedFreeFormDocumentation: Record<Locale, FreeFormDocumentationSections>;
}
interface LocalizedName {
    fallbackName: string;
    localizedName: Record<Locale, LocalizedNameField>;
}
/**
 * A localized name for the given resource.
 */
type LocalizedNameField = string;
/**
 * A localized title for the given resource.
 */
type LocalizedTitle = string;
/**
 * A localization-aware title and description.
 */
interface LocalizedTitleAndDescription {
    fallbackDescription: string;
    fallbackTitle: string;
    localizedDescription: Record<Locale, LocalizedDescription>;
    localizedTitle: Record<Locale, LocalizedTitle>;
}
/**
 * Title and description can be independently overridden.
 */
interface LocalizedTitleAndDescriptionOverride {
    descriptionOverride?: DescriptionOverride | null | undefined;
    titleOverride?: TitleOverride | null | undefined;
}
interface LocalMarketplaceDefinition {
}
interface LocalMarketplaceNotFoundRationale {
    marketplaceRid: MarketplaceRid;
}
/**
 * LocalTime string should be parsable by java.time.LocalTime.parse(String)
 * Examples "01:30", "23:00", "11:15"
 */
type LocalTime = string;
/**
 * Recommendation sourced for an upstream installation.
 */
interface LocalUpstreamInstallationRecommendationSource {
    marketplaceRidOfUpstream: MarketplaceRid;
    upstreamBlockSetInstallation: BlockSetInstallationRid;
}
interface LogicCreateBlockRequest {
    logicRid: string;
    versionId?: string | null | undefined;
}
type LogicFunctionId = string;
/**
 * / Identifier for generating the shape for a specific version of the logic function.
 */
interface LogicFunctionIdAndVersionIdentifier {
    functionId: LogicFunctionId;
    functionVersion: LogicFunctionVersion;
    logicRid: LogicRid;
}
interface LogicFunctionIdentifier_idAndVersion {
    type: "idAndVersion";
    idAndVersion: LogicFunctionIdAndVersionIdentifier;
}
type LogicFunctionIdentifier = LogicFunctionIdentifier_idAndVersion;
/**
 * / This is the shape of a single LogicFunction pinned at a VersionId within a LogicFile. A LogicFile might have many LogicFunctions, and many versions of each function. The LogicFunctionShape typically has a 1x1 mapping with a function registry function
 */
interface LogicFunctionShape {
    about: LocalizedTitleAndDescription;
    inputs: Array<LogicInputArgument>;
    logic: LogicReference;
    output: LogicOutputArgument;
}
interface LogicFunctionShapeIdentifier {
    functionId: string;
    logicRid: string;
}
type LogicFunctionVersion = string;
interface LogicIdentifier {
    rid: LogicRid;
}
interface LogicInputArgument {
    about: LocalizedTitleAndDescription;
    input: LogicInputParameterType;
}
interface LogicInputParameterType_unspecified {
    type: "unspecified";
    unspecified: UnspecifiedParameterType;
}
/**
 * A list of renderable parameter types that marketplace <-> eddie supports.
 * For now we only use
 */
type LogicInputParameterType = LogicInputParameterType_unspecified;
interface LogicOutputArgument {
    about: LocalizedTitleAndDescription;
    input: LogicOutputParameterType;
}
interface LogicOutputParameterType_unspecified {
    type: "unspecified";
    unspecified: UnspecifiedParameterType;
}
/**
 * A list of renderable output types that marketplace <-> Eddie supports.
 */
type LogicOutputParameterType = LogicOutputParameterType_unspecified;
type LogicReference = BlockInternalId;
type LogicRid = string;
/**
 * / This is the shape of the Logic compass resource
 */
interface LogicShape {
    about: LocalizedTitleAndDescription;
}
/**
 * LongListType specifies that this parameter must be a list of Longs.
 */
interface LongListType {
}
/**
 * LongType specifies that this parameter must be a Long.
 */
interface LongType {
}
type LongVersion = number;
interface MachineryCreateBlockRequest {
    rid: string;
    version?: string | null | undefined;
}
interface MachineryProcessIdentifier {
    rid: MachineryProcessRid;
}
type MachineryProcessRid = string;
interface MachineryProcessShape {
    about: LocalizedTitleAndDescription;
}
type MagritteApiName = string;
type MagritteConnectionId = string;
interface MagritteConnectionIdentifier {
    connectionId: MagritteConnectionId;
    sourceRid: MagritteSourceRid;
}
interface MagritteConnectionInputShape {
    about: LocalizedTitleAndDescription;
    connectionType: MagritteConnectionType;
    sourceReference: MagritteSourceReference;
}
/**
 * The type of connection. e.g. "http".
 */
type MagritteConnectionType = string;
/**
 * Not yet implemented by the corresponding service
 */
interface MagritteConnectorCreateBlockRequest {
    extractRids: Array<MagritteExtractRid>;
    extractsV2: Array<MagritteExtractRidAndVersion>;
    sourceId: MagritteSourceRid;
    streamingExtractRids: Array<MagritteStreamingExtractRid>;
    targetEnvironments: Array<TargetEnvironment>;
}
interface MagritteExportCreateBlockRequest {
    rid: MagritteExportRid;
    targetEnvironments: Array<TargetEnvironment>;
}
interface MagritteExportIdentifier {
    exportRid: MagritteExportRid;
}
/**
 * Equivalent to `com.palantir.magritte.exports.api.ExportId`. Refers to all exports.
 */
type MagritteExportRid = string;
interface MagritteExportShape {
    about: LocalizedTitleAndDescription;
}
/**
 * Output shape representing Magritte batch extracts.
 */
interface MagritteExtractOutputShape {
    about: LocalizedTitleAndDescription;
}
/**
 * Equivalent to `com.palantir.magritte.store.extract.api.ExtractId`. Refers only to batch extracts.
 */
type MagritteExtractRid = string;
interface MagritteExtractRidAndVersion {
    extractRid: MagritteExtractRid;
    extractVersionNumber: MagritteExtractVersionNumber;
}
type MagritteExtractVersionNumber = number;
interface MagritteRequiredApiName_requireOriginalApiName {
    type: "requireOriginalApiName";
    requireOriginalApiName: Void;
}
type MagritteRequiredApiName = MagritteRequiredApiName_requireOriginalApiName;
interface MagritteRequiredSecrets_requiredSecrets {
    type: "requiredSecrets";
    requiredSecrets: Array<MagritteSecretName>;
}
interface MagritteRequiredSecrets_allSecrets {
    type: "allSecrets";
    allSecrets: Void;
}
type MagritteRequiredSecrets = MagritteRequiredSecrets_requiredSecrets | MagritteRequiredSecrets_allSecrets;
type MagritteSecretName = string;
interface MagritteSourceConfigOverridesInputIdentifier {
    stableId: StableShapeIdentifier;
}
interface MagritteSourceConfigOverridesInputShape {
    about: LocalizedTitleAndDescription;
    stableId: StableShapeIdentifier;
}
interface MagritteSourceCreateBlockRequest {
    rid: string;
    targetEnvironments: Array<TargetEnvironment>;
}
interface MagritteSourceIdentifier {
    requiredApiName?: MagritteRequiredApiName | null | undefined;
    requiredSecrets?: MagritteRequiredSecrets | null | undefined;
    sourceRid: MagritteSourceRid;
    sourceUsageRestrictions: Array<MagritteSourceUsageRestriction>;
}
interface MagritteSourceInputShape {
    about: LocalizedTitleAndDescription;
    requiredApiName?: MagritteApiName | null | undefined;
    requiredSecrets: Array<MagritteSecretName>;
    sourceType: MagritteSourceType;
    sourceUsageRestrictions: Array<MagritteSourceUsageRestriction>;
}
interface MagritteSourceOutputShape {
    about: LocalizedTitleAndDescription;
    sourceType: MagritteSourceType;
}
type MagritteSourceReference = BlockInternalId;
type MagritteSourceRid = string;
type MagritteSourceType = string;
interface MagritteSourceUsageRestriction_stemmaRepository {
    type: "stemmaRepository";
    stemmaRepository: StemmaRepositoryType;
}
interface MagritteSourceUsageRestriction_computeModule {
    type: "computeModule";
    computeModule: ComputeModuleType;
}
interface MagritteSourceUsageRestriction_eddiePipeline {
    type: "eddiePipeline";
    eddiePipeline: EddiePipelineType;
}
type MagritteSourceUsageRestriction = MagritteSourceUsageRestriction_stemmaRepository | MagritteSourceUsageRestriction_computeModule | MagritteSourceUsageRestriction_eddiePipeline;
type MagritteSourceUsageRestrictionName = string;
interface MagritteStreamingExtractConfigOverridesInputIdentifier {
    stableId: StableShapeIdentifier;
}
interface MagritteStreamingExtractConfigOverridesInputShape {
    about: LocalizedTitleAndDescription;
    stableId: StableShapeIdentifier;
}
/**
 * Output shape representing Magritte streaming Extracts.
 */
interface MagritteStreamingExtractOutputShape {
    about: LocalizedTitleAndDescription;
}
/**
 * Equivalent to `com.palantir.magritte.streaming.api.StreamingExtractId`. Refers only to streaming extracts.
 */
type MagritteStreamingExtractRid = string;
/**
 * Represents a time period during which maintenance is allowed to take place. This is expressed
 * in terms of the time and day of week when the window starts and ends.
 *
 * A time window where windowStart and windowEnd are same can be used to indicate an "Always active"
 * maintenance window.
 *
 * Example 1:
 * windowStart: Monday 03:00
 * windowEnd: Monday 01:30
 *
 * Current date: March 13th 2023 02:00 - this is a Monday
 * Evaluated result: The maintenance window is NOT in effect
 *
 * Current date: March 13th 2023 05:00 - this is a Monday
 * Evaluated result: The maintenance window is ACTIVE
 *
 * Example 2:
 * windowStart: Monday 03:00
 * windowEnd: Monday 03:00
 *
 * Evaluated result: This window spans all time and will always be considered active.
 */
interface MaintenanceWindow {
    windowEnd: DayTime;
    windowStart: DayTime;
    zoneId: ZoneId;
}
/**
 * If no maintenance windows exist then we assume you are never in a window.
 * When supplied windows are evaluated as an OR.
 */
interface MaintenanceWindows {
    windows: Record<UpgradeType, Array<MaintenanceWindow>>;
}
/**
 * Type for identifying a block set in a managed store.
 */
interface ManagedBlockSetId {
    blockSetId: BlockSetId;
    managedMarketplaceId: ManagedMarketplaceId;
}
/**
 * A human-readable identifier for the installation. There can be only one such installation
 * within a given namespace.
 *
 * The name must:
 * - start with a lowercase letter.
 * - contain only lowercase letters, hyphens and numbers
 * - cannot contain two hyphens in a row.
 */
type ManagedInstallationName = string;
/**
 * Identifier for a managed (remote) marketplace store that is stable across stacks, e.g. "marketplace-aipnow-product-referenceresources-bundle".
 */
type ManagedMarketplaceId = string;
/**
 * Access expansion for an entire managed store.
 */
interface ManagedStoreAccessExpansion {
    accessLevel: ManagedStoreAccessLevel;
    principal: ManagedStoreAccessPrincipal;
}
interface ManagedStoreAccessExpansions {
    blockSetLevel: Array<ManagedStoreBlockSetAccessExpansion>;
    storeLevel: Array<ManagedStoreAccessExpansion>;
}
/**
 * The level of access an organization/enrollment should have on a store. Note that for a store to be visible
 * to end users in an organization, the store also needs to be enabled for that organization. This setting is
 * controlled through the `setManagedStoreSettingsForOrg` endpoint. Stores with access level `NONE` can not be
 * enabled.
 *
 * VIEW_EVERYTHING -> Permission to view, but not install, all block sets in the store.
 * INSTALL_EVERYTHING -> Permission to view and install all block sets in the store.
 * NONE -> No permission to either view or install any block sets in the store.
 */
type ManagedStoreAccessLevel = "INSTALL_EVERYTHING" | "VIEW_EVERYTHING" | "NONE";
interface ManagedStoreAccessPrincipal_organization {
    type: "organization";
    organization: OrganizationRid;
}
interface ManagedStoreAccessPrincipal_enrollment {
    type: "enrollment";
    enrollment: EnrollmentRid;
}
type ManagedStoreAccessPrincipal = ManagedStoreAccessPrincipal_organization | ManagedStoreAccessPrincipal_enrollment;
/**
 * Access expansion for a single block set in a managed store.
 */
interface ManagedStoreBlockSetAccessExpansion {
    accessLevel: ManagedStoreBlockSetAccessLevel;
    blockSetId: BlockSetId;
    principal: ManagedStoreAccessPrincipal;
}
/**
 * The level of access an organization/enrollment should have on a specific block set in a store.
 *
 * INSTALL -> Permission to install the block set.
 */
type ManagedStoreBlockSetAccessLevel = "INSTALL";
/**
 * If `isEnabled` is set to true, and `managedStoreGroupConfiguration` is empty, all users in the organization
 * will be granted access to the store. The level of access that they get will be determined by the level of
 * access the organization has to the store, see docs on `ApolloStackLevelConfig` and `ManagedStoreAccessLevel`.
 *
 * If `isEnabled` is set to true, and `managedStoreGroupConfiguration` is not empty, only users in the organization
 * that are members of the given groups will be granted access to the store. The level of access that they get
 * will be determined by the level of access the organization has to the store, same as above.
 *
 * If `isEnabled` is set to false, the store is disabled for the organization and no user in the organization will
 * be granted access to it. ManagedStoreGroupConfiguration must be empty else we throw
 * `InvalidAdminSettingsRequested`.
 */
interface ManagedStoreConfiguredSettingsEntry {
    isEnabled: boolean;
    managedStoreGroupConfiguration?: ManagedStoreGroupConfiguration | null | undefined;
}
interface ManagedStoreGroupConfiguration {
    groupIds: Array<GroupId>;
}
interface ManagedStoreResponseEntry {
    managedMarketplaceId?: ManagedMarketplaceId | null | undefined;
    managedMarketplaceIds: Array<ManagedMarketplaceId>;
    rid: MarketplaceRid;
    storeName: StoreName;
}
interface ManagedStoreSettingsResponseEntry {
    configuredSettings: ManagedStoreConfiguredSettingsEntry;
    rid: MarketplaceRid;
    storeName: StoreName;
}
/**
 * The resolved input shape does not satisfy the input presets, even though the presets are mandatory.
 */
interface MandatoryPresetNotUsed {
    actual: ResolvedBlockSetInputShape;
    presets: Array<ResolvedBlockSetInputShape>;
}
interface ManifestOnlyBlockSpecificConfigurationV0 {
    manifest: BlockDataId;
}
interface ManuallyProvidedInput {
}
/**
 * An input that was manually provided by the user during installation.
 */
interface ManuallyProvidedInputV2 {
    resolvedInput: ResolvedBlockSetInputShape;
}
/**
 * A snapshot that was manually triggered.
 */
interface ManualProductGroupSnapshotTrigger {
    createdBy: MultipassUserId;
    description?: LocalizedDescription | null | undefined;
}
interface ManyToManyLinkTypeApiNames {
    objectTypeAToBApiName: ObjectTypeFieldApiName;
    objectTypeBToAApiName: ObjectTypeFieldApiName;
}
/**
 * DEPRECATED. Use "MapRendererSetIdentifierV2" instead.
 */
interface MapRendererSetIdentifier {
    objectTypeRid: ObjectTypeRid;
}
interface MapRendererSetIdentifierV2 {
    locator: MapRendererSetLocator;
}
interface MapRendererSetLocator_objectTypeRid {
    type: "objectTypeRid";
    objectTypeRid: ObjectTypeRid;
}
interface MapRendererSetLocator_interfaceTypeRid {
    type: "interfaceTypeRid";
    interfaceTypeRid: InterfaceTypeRid;
}
type MapRendererSetLocator = MapRendererSetLocator_objectTypeRid | MapRendererSetLocator_interfaceTypeRid;
interface MapRendererSetOutputShape {
    about: LocalizedTitleAndDescription;
}
interface MapRendererSetOutputShapeV2 {
    about: LocalizedTitleAndDescription;
}
interface MapRenderingServiceCreateBlockRequest {
    locator: MapRenderingServiceLocator;
}
interface MapRenderingServiceLocator_objectTypeRid {
    type: "objectTypeRid";
    objectTypeRid: string;
}
interface MapRenderingServiceLocator_interfaceTypeRid {
    type: "interfaceTypeRid";
    interfaceTypeRid: string;
}
type MapRenderingServiceLocator = MapRenderingServiceLocator_objectTypeRid | MapRenderingServiceLocator_interfaceTypeRid;
type MarkdownText = string;
/**
 * A marketplace contains blocks.
 */
interface Marketplace {
    marketplaceRid: MarketplaceRid;
}
interface MarketplaceBulkResult {
    marketplaceRids: Array<MarketplaceRid>;
}
interface MarketplaceDefinition_local {
    type: "local";
    local: LocalMarketplaceDefinition;
}
type MarketplaceDefinition = MarketplaceDefinition_local;
/**
 * Rid to manage permissions for a marketplace store to be read by foundry search.
 */
type MarketplaceFoundrySearchSecurityRid = string;
/**
 * A monotonically increasing version number for store metadata.
 */
type MarketplaceMetadataVersion = string;
/**
 * Rid for the marketplace store.
 */
type MarketplaceRid = string;
type MarkingId = string;
/**
 * MarkingListType specifies that this parameter must be a list of Markings.
 */
interface MarkingListType {
}
/**
 * The marking referenced by the resolved shape was not found. This could happen if the
 * marking doesn't exist or is not visible to the user.
 */
interface MarkingNotFound {
    markingId: MarkingId;
}
/**
 * MarkingOperation defines the level of user permissions required to install a package with this Marking. For
 * DECLASSIFY, the user must have declassify permissions on the marking. For USE, the user must have use
 * permissions on the marking. For NONE, no permissions are required to use this marking. NONE should only be set
 * by integrations that set Marking constraints on resources (e.g. the Ontology integration with Marking property
 * types).
 */
type MarkingOperation = "DECLASSIFY" | "USE" | "NONE";
/**
 * Each individual marking (supporting both CBAC and Mandatory markings) is resolved using either
 * the globalMarkingId or the displayName. Since the globalMarkingId is guaranteed to be globally unique,
 * we use just this field to generate the resolved input shape if it exists. Otherwise, we attempt to generate
 * the resolved input shape using just the display name for the marking. The display name is used only if there
 * exists exactly one marking with the display name (otherwise we don't allow presets). We require that either
 * the global marking id or display name exists for each marking to allow presets for the Markings input shape.
 */
interface MarkingResolver {
    displayName: string;
    globalMarkingId?: string | null | undefined;
}
interface MarkingsIdentifier {
    about: LocalizedTitleAndDescription;
    affectedShapes: Array<DatasourceLocator>;
    affectedShapesV2: Array<ShapesAffectedByMarkings>;
    markingIds: Array<MarkingId>;
    operation: MarkingOperation;
    sizeConstraints?: MarkingsSizeConstraints | null | undefined;
    stableId?: StableShapeIdentifier | null | undefined;
    supportedMarkingsType?: SupportedMarkingsType | null | undefined;
    supportedMarkingsTypesV2?: Array<SupportedMarkingsTypeV2> | null | undefined;
}
interface MarkingSizeConstraintsNotSatisfied {
    actualNumber: number;
    maxNumberInclusive: number;
    minNumberInclusive: number;
}
interface MarkingsShape {
    about: LocalizedTitleAndDescription;
    affectedShapes: Array<BlockInternalId>;
    operation: MarkingOperation;
    sizeConstraints?: MarkingsSizeConstraints | null | undefined;
    stableId?: StableShapeIdentifier | null | undefined;
    supportedMarkingsType?: SupportedMarkingsType | null | undefined;
    supportedMarkingsTypesV2?: Array<SupportedMarkingsTypeV2> | null | undefined;
}
interface MarkingsSizeConstraints {
    maxNumberInclusive: number;
    minNumberInclusive: number;
}
/**
 * Similar to the `MarkingType` enum in Multipass, but we include a third `ORGANIZATION` type to model
 * organization markings.
 */
type MarkingsType = "MANDATORY" | "CBAC" | "ORGANIZATION";
/**
 * MarkingType specifies that this parameter must be a CBAC or Madatory Marking type.
 */
interface MarkingType {
}
/**
 * The MarkingType of the markings referenced by the resolved shape did not match the specified MarkingType.
 */
interface MarkingTypeNotValid {
    markingIds: Array<MarkingId>;
    markingType: SupportedMarkingsType;
}
/**
 * The MarkingType of the markings referenced by the resolved shape did not match the specified MarkingType.
 */
interface MarkingTypeNotValidV2 {
    invalidMarkings: Record<MarkingId, MarkingsType>;
    supportedMarkingsType: SupportedMarkingsType;
}
/**
 * The MarkingType of the markings referenced by the resolved shape did not match any of the specified
 * supported markings types.
 */
interface MarkingTypeNotValidV3 {
    invalidMarkings: Record<MarkingId, MarkingsType>;
    supportedMarkingsTypes: Array<SupportedMarkingsTypeV2>;
}
type MaterializationBehavior = "INCLUDED" | "EXCLUDED";
interface MaterializingBlockSetVersionStatus {
    currentUpdateId?: UpdatePendingBlockSetVersionSpecsRequestId | null | undefined;
    outputSpecResults: Array<OutputSpecResult>;
    previousOutputSpecResults: Array<OutputSpecResult>;
}
interface MavenCoordinateDependency {
    maxVersion: string;
    minVersion: string;
    optional?: boolean | null | undefined;
    productId: MavenProductId;
}
/**
 * A set of maven coordinates that are able to be signed by a public key.
 */
interface MavenCoordinates {
    mavenCoordinates: Array<MavenProductId>;
}
/**
 * Maven group (part of a maven product id, before the colon)
 */
type MavenGroup = string;
interface MavenLocator {
    path: string;
}
/**
 * Maven Product Id which will be used to identify the released products.
 * e.g com.palantir.foundry.example:example-service
 */
type MavenProductId = string;
/**
 * Either a Maven Coordinate (=with version), or a Maven Product Id (=without version).
 *
 * <mavenGroup>:<mavenArtifact>(:<mavenVersion>)?
 *
 * Omitting the maven version is only allowed for unprivileged Apollo spaces.
 *
 * Examples:
 * - com.example.service:package-name:1.2.3
 * - com.example.service:package-name
 */
type MavenProductIdOrCoordinate = string;
/**
 * MediaReferenceListType specifies that this parameter must be a list of MediaReferences.
 */
interface MediaReferenceListType {
}
/**
 * MediaReferenceType specifies that this parameter must be a MediaReference.
 */
interface MediaReferenceType {
}
interface MediaSchema_document {
    type: "document";
    document: DocumentSchema;
}
interface MediaSchema_any {
    type: "any";
    any: Void;
}
interface MediaSchema_unspecified {
    type: "unspecified";
    unspecified: Void;
}
/**
 * deprecated
 */
type MediaSchema = MediaSchema_document | MediaSchema_any | MediaSchema_unspecified;
/**
 * deprecated
 */
type MediaSchemaType = "ANY" | "IMAGERY" | "AUDIO" | "VIDEO" | "DOCUMENT" | "DICOM" | "EMAIL" | "SPREADSHEET" | "MULTIMODAL" | "MODEL_3D" | "STREAMING_VIDEO";
interface MediaSchemaTypeV2_any {
    type: "any";
    any: AnySchema;
}
interface MediaSchemaTypeV2_imagery {
    type: "imagery";
    imagery: ImagerySchema;
}
interface MediaSchemaTypeV2_audio {
    type: "audio";
    audio: AudioSchema;
}
interface MediaSchemaTypeV2_document {
    type: "document";
    document: DocumentSchema;
}
interface MediaSchemaTypeV2_dicom {
    type: "dicom";
    dicom: DicomSchema;
}
interface MediaSchemaTypeV2_email {
    type: "email";
    email: EmailSchema;
}
interface MediaSchemaTypeV2_spreadsheet {
    type: "spreadsheet";
    spreadsheet: SpreadsheetSchema;
}
interface MediaSchemaTypeV2_video {
    type: "video";
    video: VideoSchema;
}
interface MediaSchemaTypeV2_multiModal {
    type: "multiModal";
    multiModal: MultiModalSchema;
}
interface MediaSchemaTypeV2_model3d {
    type: "model3d";
    model3d: Model3dSchema;
}
interface MediaSchemaTypeV2_streamingVideo {
    type: "streamingVideo";
    streamingVideo: StreamingVideoSchema;
}
/**
 * updated media schema copied from mio-api without additional constraints
 */
type MediaSchemaTypeV2 = MediaSchemaTypeV2_any | MediaSchemaTypeV2_imagery | MediaSchemaTypeV2_audio | MediaSchemaTypeV2_document | MediaSchemaTypeV2_dicom | MediaSchemaTypeV2_email | MediaSchemaTypeV2_spreadsheet | MediaSchemaTypeV2_video | MediaSchemaTypeV2_multiModal | MediaSchemaTypeV2_model3d | MediaSchemaTypeV2_streamingVideo;
interface MediaSetCreateBlockRequest {
    branch: string;
    includeMediaSetItems: boolean;
    pinnedMediaSetView?: PinnedMediaSetView | null | undefined;
    rid: string;
}
interface MediaSetDatasourceType {
    mediaSchema: MediaSchema;
    mediaSchemaType?: MediaSchemaType | null | undefined;
    mediaSchemaTypeV2?: MediaSchemaTypeV2 | null | undefined;
    pathPolicy: PathPolicy;
    transactionPolicy?: MediaSetTransactionPolicy | null | undefined;
}
interface MediaSetLocator {
    branch: string;
    rid: string;
}
interface MediaSetOutputSpecConfig {
    includeData: boolean;
}
interface MediaSetTransactionPolicy_any {
    type: "any";
    any: Void;
}
interface MediaSetTransactionPolicy_batchTransactions {
    type: "batchTransactions";
    batchTransactions: Void;
}
interface MediaSetTransactionPolicy_noTransactions {
    type: "noTransactions";
    noTransactions: Void;
}
type MediaSetTransactionPolicy = MediaSetTransactionPolicy_any | MediaSetTransactionPolicy_batchTransactions | MediaSetTransactionPolicy_noTransactions;
/**
 * A group of product group members that are strongly connected in the dependency graph. Members
 * in this group have mutual input-output dependencies, making them uninstallable as a unit because
 * no consistent topological ordering exists.
 *
 * One finding is emitted per non-trivial strongly-connected component (size at least 2), carrying
 * the full member set and every directed edge between them. This rolls up what would otherwise be
 * an explosion of redundant simple-cycle findings covering the same underlying connectivity
 * problem.
 *
 * Only top-level (parent) shapes participate in cycle detection. A dependency that exists solely
 * through child shapes — via merge-key matches or recommendation mappings on child shape IDs — is
 * not considered when computing strongly-connected components.
 */
interface MemberDependencyCycle {
    dependencyEdges: Array<CycleDependencyEdge>;
    members: Array<ProductGroupMemberRid>;
}
type MeshId = string;
/**
 * This specifies that the installed profile will govern data peered to all members
 * of the identified Mesh Manager mesh.
 */
interface MeshIdRemoteStrategy {
    meshId: MeshId;
}
type MeshNodeLabel = string;
/**
 * This specifies that the installed profile will govern data peered to members
 * of the identified Mesh Manager mesh with the given label(s).
 */
interface MeshNodeLabelRemoteStrategy {
    meshId: MeshId;
    meshNodeLabels: Array<MeshNodeLabel>;
}
/**
 * A media type for an attachment, see https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types.
 */
type MimeType = string;
/**
 * CBAC marking constraints are required but were not provided. CBAC marking constraints must always be provided
 * for stacks that have CBAC enabled.
 */
interface MissingCbacMarkingConstraint {
}
/**
 * The typeClass required on the column shape is missing on the resolved column.
 */
interface MissingColumnTypeClass {
    expected: Array<DatasourceColumnTypeClass>;
}
/**
 * There should have been an internal recommendation between an output and an input, but there wasn't. This can
 * happen if two blocks declare resolved shapes for the same resource, but with different shape types, e.g. if
 * one block declares an output for a dataset as a tabular datasource, and another block declares an input for
 * the same dataset as a files datasource.
 */
interface MissingInternalRecommendationError {
    inputShape: BlockSetInputShape;
    inputShapeId: InputBlockSetShapeId;
    outputShapeId: OutputBlockSetShapeId;
    resolvedInputShape?: ResolvedBlockSetInputShape | null | undefined;
    resolvedOutputShape: ResolvedBlockSetOutputShape;
}
/**
 * Generic error that can be used to signal that the user is missing some Gatekeeper operation on a certain
 * resource.
 */
interface MissingOperationError {
    missingOperation: string;
    rid: string;
}
/**
 * One or more input shapes on a downstream member have no valid fulfilling recommendation,
 * but another member in the group produces a matching output. Aggregated per member,
 * grouped by rollup parent shape. Always WARN level.
 *
 * A recommendation is considered invalid (and therefore non-fulfilling) when it points at
 * an upstream output that no longer exists on the upstream's resolved version. Such inputs
 * are surfaced via `staleRecommendations` on each shape entry — the suggested remediation
 * for those is "regenerate the recommendation" rather than "create one".
 */
interface MissingRecommendation {
    downstream: ProductGroupMemberRid;
    missingShapes: Array<MissingRecommendationShape>;
}
/**
 * Missing-recommendation inputs grouped by parent shape, mirroring UnfulfilledInputShape.
 * Providers are merged across all inputs in the group — deduplicated by upstream member with
 * `matchingOutputShapeIds` unioned.
 *
 * When the parent shape is missing a recommendation, `missingChildShapeIds` is empty — the
 * parent-level entry covers any children missing a recommendation.
 */
interface MissingRecommendationShape {
    missingChildShapeIds: Array<InputBlockSetShapeId>;
    parentShapeId: InputBlockSetShapeId;
    providers: Array<PotentialInputProvider>;
    staleRecommendations: Array<StaleRecommendation>;
}
interface MkvVideoContainerFormat {
}
interface Model3dDecodeFormat_las {
    type: "las";
    las: LasFormat;
}
interface Model3dDecodeFormat_ply {
    type: "ply";
    ply: PlyFormat;
}
interface Model3dDecodeFormat_obj {
    type: "obj";
    obj: ObjFormat;
}
type Model3dDecodeFormat = Model3dDecodeFormat_las | Model3dDecodeFormat_ply | Model3dDecodeFormat_obj;
interface Model3dSchema {
    format: Model3dDecodeFormat;
    modelType?: Model3dType | null | undefined;
}
/**
 * The type of 3D model representation
 */
type Model3dType = "POINT_CLOUD" | "MESH";
interface ModelCreateBlockRequest {
    includeContent?: IncludeModelContent | null | undefined;
    modelRid: string;
    modelVersionRid: string;
}
interface ModelInputIdentifier {
    allowedTypes: Array<ModelType>;
    rid: ModelRid;
    version?: ModelVersionRid | null | undefined;
}
interface ModelInputShape {
    about: LocalizedTitleAndDescription;
    allowedTypes: Array<ModelType>;
    type: ModelType;
}
interface ModelOutputIdentifier {
    buildRequirements?: DatasourceBuildRequirements | null | undefined;
    rid: ModelRid;
    version: ModelVersionRid;
}
interface ModelOutputShape {
    about: LocalizedTitleAndDescription;
    buildRequirements?: DatasourceBuildRequirements | null | undefined;
    type: ModelType;
}
interface ModelOutputSpecConfig {
    includeContent: boolean;
}
/**
 * The service to which rid belongs is different from the one that was expected.
 */
interface ModelResourceShapeServiceMismatch {
    actual: ServiceName;
    expected: ServiceName;
}
/**
 * The type of the rid is different from the one that was expected.
 */
interface ModelResourceTypeMismatch {
    actual: ResourceType;
    expected: ResourceType;
}
type ModelRid = string;
/**
 * A Model Studio config.
 */
interface ModelStudioConfig {
    modelStudioConfigRid: string;
    modelStudioConfigVersionId?: number | null | undefined;
}
interface ModelStudioConfigIdentifier {
    modelStudioConfigRid: ModelStudioConfigRid;
    modelStudioRid: ModelStudioRid;
}
type ModelStudioConfigReference = BlockInternalId;
type ModelStudioConfigRid = string;
/**
 * Selects a specific Model Studio config version to package.
 */
interface ModelStudioConfigSelector {
    modelStudioConfigRid: string;
    modelStudioConfigVersionId: number;
}
interface ModelStudioConfigShape {
    about: LocalizedTitleAndDescription;
    modelStudio: ModelStudioReference;
}
/**
 * Creates a Model Studio block.
 */
interface ModelStudioCreateBlockRequest {
    modelStudioConfigs: Array<ModelStudioConfigSelector>;
    modelStudioRid: string;
}
interface ModelStudioIdentifier {
    rid: ModelStudioRid;
}
interface ModelStudioInputShape {
    about: LocalizedTitleAndDescription;
}
interface ModelStudioOutputShape {
    about: LocalizedTitleAndDescription;
    configs: Array<ModelStudioConfigReference>;
}
interface ModelStudioOutputSpecConfig {
    modelStudioConfigs: Array<ModelStudioConfig>;
}
type ModelStudioReference = BlockInternalId;
type ModelStudioRid = string;
interface ModelType_container {
    type: "container";
    container: Void;
}
interface ModelType_binary {
    type: "binary";
    binary: Void;
}
interface ModelType_modelSourceNotMarketplaceCompatible {
    type: "modelSourceNotMarketplaceCompatible";
    modelSourceNotMarketplaceCompatible: Void;
}
type ModelType = ModelType_container | ModelType_binary | ModelType_modelSourceNotMarketplaceCompatible;
/**
 * DEPRECATED. Use ModelTypeMismatchV3 instead.
 * The model type was different than one that was expected.
 */
interface ModelTypeMismatch {
    actual: string;
    resolvedShapeModelType: ModelType;
    unresolvedShapeModelType: ModelType;
}
/**
 * DEPRECATED. Use ModelTypeMismatchV3 instead.
 * The model type was different than one that was expected.
 */
interface ModelTypeMismatchV2 {
    actual: string;
    allowedModelTypesFromUnresolvedShape: Array<ModelType>;
    resolvedShapeModelType: ModelType;
}
/**
 * The model type was different than one that was expected.
 */
interface ModelTypeMismatchV3 {
    actual: string;
    allowedModelTypesFromUnresolvedShape: Array<ModelType>;
}
type ModelVersionRid = string;
interface ModifyExistingBlockSetInstallation {
    forceInstall?: boolean | null | undefined;
    targetLocation?: SetTargetInstallLocation | null | undefined;
    targetState: BlockSetInstallationTargetState;
}
/**
 * Request to add and/or remove installations from an existing draft. Added installations will have their
 * input mappings copied from the previous version synchronously. We will asynchronously resolve the remaining
 * input mappings using presets, automapping, and external recommendations.
 */
interface ModifyJobDraftInstallationsRequest {
    add: Array<TargetInstallationSpec>;
    additionalRecommendationsToConsider: Array<UpstreamRecommendation>;
    remove: Array<BlockSetInstallationRid>;
}
interface ModifyJobDraftInstallationsResponse {
    draft: UnresolvedJobDraft;
    metadata: JobDraftMetadata;
}
interface MonitorIdentifier {
    rid: string;
}
interface MonitoringViewCreateBlockRequest {
    monitoringViewRid: string;
}
interface MonitorShape {
    about: LocalizedTitleAndDescription;
}
interface MonitorViewIdentifier {
    rid: string;
}
interface MonitorViewShape {
    about: LocalizedTitleAndDescription;
}
/**
 * Monocle Entity Identifier for generating monocle graph shapes
 */
interface MonocleGraphIdentifier {
    rid: string;
}
interface MonocleGraphShape {
    about: LocalizedTitleAndDescription;
}
interface MoveBlockSetInstallationsRequest {
    installationRids: Array<BlockSetInstallationRid>;
    targetMarketplaceRid: MarketplaceRid;
}
interface MoveBlockSetInstallationsResponse {
}
interface MovVideoContainerFormat {
}
interface Mp2Format {
}
interface Mp3Format {
}
interface Mp4AudioContainerFormat_singleStream {
    type: "singleStream";
    singleStream: SingleStreamMp4AudioContainerFormat;
}
/**
 * An audio only mp4 container. Does not contain any non-audio streams.
 */
type Mp4AudioContainerFormat = Mp4AudioContainerFormat_singleStream;
interface Mp4VideoContainerFormat {
}
interface MultiModalSchema {
}
/**
 * Unique identifier for a group in Multipass.
 */
type MultipassGroupId = string;
/**
 * A resolver for multipass group that uses realm and name for cross-stack identification.
 */
interface MultipassGroupResolver {
    name: string;
    realm: string;
}
interface MultipassGroupShape {
    about: LocalizedTitleAndDescription;
}
/**
 * A user attribute name in Multipass.
 */
type MultipassUserAttributeName = string;
interface MultipassUserAttributeShape {
    about: LocalizedTitleAndDescription;
}
/**
 * Unique identifier for a user in Multipass.
 */
type MultipassUserId = string;
interface NameBasedDatasourceColumnIdentifier {
    datasource: DatasourceLocatorIdentifier;
    name: string;
}
interface NamedCredentialCreateBlockRequest {
    rid: string;
}
/**
 * Will generate a named credential shape with all secret names from the given credential.
 */
interface NamedCredentialIdentifier {
    credentialRid: CredentialRid;
}
interface NamedCredentialShape {
    about: LocalizedTitleAndDescription;
    secretNames: Array<SecretName>;
}
type NamespaceRid = string;
interface NetworkEgressPolicyCreateBlockRequest {
    rid: string;
}
type NetworkEgressPolicyIdentifier = string;
interface NetworkEgressPolicyShape {
    about: LocalizedTitleAndDescription;
}
/**
 * A new blockSetInstallation that will be created with the provided blockSetVersionId and mapping
 */
interface NewAssociatedBlockSetInstallation {
    blockSetVersionId: BlockSetVersionId;
    compassSettings?: CompassSettings | null | undefined;
    displayMetadata: BlockSetInstallationDisplayMetadata;
    id: NewBlockSetInstallationId;
    mapping: Record<BlockSetBlockInstanceId, BlockReference>;
}
type NewBlockSetInstallationId = string;
/**
 * A new installation in the request constains a singleton product which is already installed in the namespace.
 * Singletons cannot be installed into a namespace that already has an installation of that blockset.
 * This is a blocking error.
 */
interface NewInstallationOfSingletonBlockSetThatIsAlreadyInstalled {
    existingInstallations: Array<BlockSetInstallationRid>;
}
interface NewProject {
    cbacMarkingConstraint?: CbacMarkingConstraint | null | undefined;
    organizationMarkingIds?: Array<MarkingId> | null | undefined;
    roleContext: InstallationProjectRoleContext;
    roleGrants: Array<RoleGrant>;
}
/**
 * Ephemeral identifier that only makes sense within the context of an InstallBlockSetsRequest.
 */
type NewProjectId = string;
interface NewProjectOrExistingFolder_newProject {
    type: "newProject";
    newProject: NewProject;
}
interface NewProjectOrExistingFolder_existingFolder {
    type: "existingFolder";
    existingFolder: ExistingFolder;
}
type NewProjectOrExistingFolder = NewProjectOrExistingFolder_newProject | NewProjectOrExistingFolder_existingFolder;
interface NewProjectOrExistingFolderV2_newProject {
    type: "newProject";
    newProject: NewProjectV2;
}
interface NewProjectOrExistingFolderV2_existingFolder {
    type: "existingFolder";
    existingFolder: ExistingFolderV2;
}
type NewProjectOrExistingFolderV2 = NewProjectOrExistingFolderV2_newProject | NewProjectOrExistingFolderV2_existingFolder;
interface NewProjectV2 {
    id: NewProjectId;
}
/**
 * Although this often has the file extension .wav, it's a distinct format.
 * See https://www1.icsi.berkeley.edu/Speech/faq/wavfile-fmts.html
 */
interface NistSphereFormat {
}
interface NitfFormat {
}
type NonConstraintFailureNotificationCause = "INSTALLATION_JOB_SUCCESS" | "INSTALLATION_JOB_FAILURE" | "UPGRADE_PLAN_FAILURE" | "BEGINNING_UPGRADE" | "IDLING";
interface NonEmptyCompassInstallLocation {
    childrenRids: Array<string>;
    compassFolderRid: CompassFolderRid;
}
/**
 * Constraint Failure when there are no newer product versions on the release channel the installation is tracking
 * Recalled versions that were skipped during the upgrade planning are also included here.
 */
interface NoNewerVersionsOnReleaseChannelConstraintFailure {
    newerVersionsOnOtherChannels: Record<BlockSetVersionId, Array<ReleaseChannel>>;
    skippedRecalledVersions: Array<BlockSetVersionId>;
}
interface NormalizationMaxClassificationIdentifier {
    rid: NormalizationMaxClassificationRid;
}
interface NormalizationMaxClassificationOutputShape {
    about: LocalizedTitleAndDescription;
}
type NormalizationMaxClassificationRid = string;
interface NotAuthorizedToDeclassify {
}
/**
 * User did not have sufficient permissions to remove one or more markings from a resource.
 */
interface NotAuthorizedToDeclassifyError {
    rid: string;
}
interface NotAuthorizedToDeclassifyRationale {
    rid: string;
}
interface NotAuthorizedToUseMarkings {
    markingIds: string;
}
/**
 * User did not have sufficient permissions to use one or more markings.
 */
interface NotAuthorizedToUseMarkingsError {
    markingIds: string;
    rid: string;
}
/**
 * User did not have sufficient permissions to use one or more markings.
 */
interface NotAuthorizedToUseMarkingsErrorV2 {
    markingIds: Array<string>;
    rid: string;
}
interface NotAuthorizedToUseMarkingsRationale {
    rid: string;
}
interface NotepadCreateBlockRequest {
    notepadContentVersion?: number | null | undefined;
    rid: string;
}
/**
 * Notepad document that can be opened on its own or referenced in Workshop or Carbon.
 */
interface NotepadDocumentShape {
    about: LocalizedTitleAndDescription;
}
/**
 * Notepad document that can be opened on its own or referenced in Workshop or Carbon.
 */
interface NotepadPartialResolvedShape {
    rid: string;
}
interface NotepadTemplateCreateBlockRequest {
    rid: string;
    version: number;
}
interface NotepadTemplateIdentifier_rid {
    type: "rid";
    rid: NotepadTemplateRid;
}
interface NotepadTemplateIdentifier_ridAndVersion {
    type: "ridAndVersion";
    ridAndVersion: NotepadTemplateRidAndVersion;
}
type NotepadTemplateIdentifier = NotepadTemplateIdentifier_rid | NotepadTemplateIdentifier_ridAndVersion;
type NotepadTemplateParameterId = string;
interface NotepadTemplateParameterIdAndTemplate {
    id: NotepadTemplateParameterId;
    templateIdentifier: NotepadTemplateIdentifier;
}
interface NotepadTemplateParameterIdentifier_idAndTemplate {
    type: "idAndTemplate";
    idAndTemplate: NotepadTemplateParameterIdAndTemplate;
}
type NotepadTemplateParameterIdentifier = NotepadTemplateParameterIdentifier_idAndTemplate;
type NotepadTemplateParameterReference = BlockInternalId;
interface NotepadTemplateParameterShape {
    about: LocalizedTitleAndDescription;
    template: NotepadTemplateReference;
    type: NotepadTemplateParameterType;
}
type NotepadTemplateParameterType = "DATE" | "NUMBER" | "OBJECT" | "OBJECT_SET" | "STRING" | "TIMESTAMP";
/**
 * The type of the provided parameter does not match the packaged resource.
 */
interface NotepadTemplateParameterTypeMismatch {
    actual: NotepadTemplateParameterType;
    expected: NotepadTemplateParameterType;
}
type NotepadTemplateReference = BlockInternalId;
type NotepadTemplateRid = string;
interface NotepadTemplateRidAndVersion {
    rid: NotepadTemplateRid;
    version: NotepadTemplateVersion;
}
/**
 * Notepad template that serves as a blueprint for generating new documents based on inputs.
 */
interface NotepadTemplateShape {
    about: LocalizedTitleAndDescription;
    parameters: Array<NotepadTemplateParameterReference>;
}
type NotepadTemplateVersion = number;
interface NotificationCause_nonConstraintFailureNotificationCause {
    type: "nonConstraintFailureNotificationCause";
    nonConstraintFailureNotificationCause: NonConstraintFailureNotificationCause;
}
interface NotificationCause_constraintFailure {
    type: "constraintFailure";
    constraintFailure: ConstraintFailure;
}
type NotificationCause = NotificationCause_nonConstraintFailureNotificationCause | NotificationCause_constraintFailure;
interface NotificationMechanism {
    emailNotification: Array<NotificationScope>;
    pagerDutyNotification: Array<NotificationScope>;
}
interface NotificationMechanismsTargets {
    targets: Record<NotificationType, NotificationMechanism>;
}
interface NotificationRecipientUserId {
    user: string;
}
interface NotificationScope_user {
    type: "user";
    user: NotificationRecipientUserId;
}
type NotificationScope = NotificationScope_user;
type NotificationType = "CONSTRAINT_FAILURE_LOUD" | "CONSTRAINT_FAILURE_QUIET" | "INSTALL_JOB_SUCCESS" | "INSTALL_JOB_FAILURE" | "OTHER_EVENT" | "OTHER_FAILURE";
interface NotStartedInstallPendingStatus {
}
interface NpmLocator {
    name: string;
    version: string;
}
interface NumberOfInstallationsInRequestLimitExceeded {
    limit: number;
    numberInRequest: number;
}
interface OacPermissionMetadata {
    marketplaceRid: MarketplaceRid;
    mavenCoordinates: MavenCoordinates;
    publicKey: SigningPublicKey;
}
/**
 * An entry in the OAC signing key table
 */
interface OacSigningKeyEntry {
    keyId: string;
    mavenCoordinates: MavenCoordinates;
    publicKey: SigningPublicKey;
}
interface ObjectInstanceIdentifier {
    rid: ObjectRid;
}
interface ObjectInstanceInputShape {
    about: LocalizedTitleAndDescription;
    objectTypeIdentifier: ObjectTypeReference;
}
interface ObjectInstanceNotFound {
    objectInstanceRid: ObjectRid;
}
interface ObjectParameterPropertyValue {
    parameterId: ActionTypeParameterReference;
    propertyTypeId: ObjectTypePropertyReference;
}
interface ObjectPropertyType_primitive {
    type: "primitive";
    primitive: PrimitiveObjectPropertyType;
}
interface ObjectPropertyType_array {
    type: "array";
    array: ArrayObjectPropertyType;
}
/**
 * Wrapper which refers to an Ontology property type and supports describing complex property types (array).
 */
type ObjectPropertyType = ObjectPropertyType_primitive | ObjectPropertyType_array;
/**
 * ObjectReferenceListType specifies that this parameter must be a list of ObjectLocators.
 */
interface ObjectReferenceListType {
    objectTypeId: ObjectTypeReference;
}
/**
 * ObjectReferenceType specifies that this parameter must be an ObjectLocator.
 */
interface ObjectReferenceType {
    objectTypeId: ObjectTypeReference;
}
type ObjectRid = string;
/**
 * The resolved Objects backend support for the Object Type / ManyToMany Link is incompatible
 * with what is required.
 */
interface ObjectsBackendIncompatible {
    actual: OutputObjectBackendVersion;
    required: InputObjectBackendVersion;
}
/**
 * The resolved Objects backend for the Object Type / ManyToMany Link is not supported by Marketplace.
 */
interface ObjectsBackendUnknown {
    backend: string;
}
interface ObjectSetCreateBlockRequest {
    rids: Array<string>;
}
interface ObjectSetIdentifier {
    rid: ObjectSetRid;
}
type ObjectSetRid = string;
/**
 * ObjectSetRidType specifies that this parameter must be an ObjectSetRid.
 */
interface ObjectSetRidType {
    objectTypeId: ObjectTypeReference;
}
interface ObjectSetShape {
    about: LocalizedTitleAndDescription;
}
type ObjectTypeApiName = string;
/**
 * A string indicating the API Name to use for the given entity that will be a field of an ObjectType.
 * This API name will be used to access the entity in programming languages.
 * It must adhere to the following rules:
 * - Match the unicode identifier syntax: https://unicode.org/reports/tr31/
 * - Contain at most 100 characters.
 */
type ObjectTypeFieldApiName = string;
type ObjectTypeId = string;
interface ObjectTypeIdentifier_rid {
    type: "rid";
    rid: ObjectTypeRid;
}
interface ObjectTypeIdentifier_id {
    type: "id";
    id: ObjectTypeId;
}
type ObjectTypeIdentifier = ObjectTypeIdentifier_rid | ObjectTypeIdentifier_id;
interface ObjectTypeInputShape {
    about: LocalizedTitleAndDescription;
    editsSupport: InputEditsSupport;
    objectsBackendVersion: InputObjectBackendVersion;
    propertyTypes: Array<ObjectTypePropertyReference>;
}
/**
 * Identifies a specific interface link implementation on an ObjectType. An ObjectType may implement the same
 * InterfaceLinkType using multiple distinct LinkTypes, so both rids are required to uniquely identify the
 * implementation.
 */
interface ObjectTypeInterfaceLinkImplementation {
    interfaceLinkTypeRid: InterfaceLinkTypeRid;
    linkTypeRid: LinkTypeRid;
}
interface ObjectTypeNotFound {
    objectTypeId?: ObjectTypeId | null | undefined;
    objectTypeRid?: ObjectTypeRid | null | undefined;
}
interface ObjectTypeOutputShape {
    about: LocalizedTitleAndDescription;
    editsSupport: OutputEditsSupport;
    objectsBackendVersion: OutputObjectBackendVersion;
    propertyTypes: Array<ObjectTypePropertyReference>;
}
/**
 * Per-object-type packaging configurations.
 */
interface ObjectTypeOutputSpecConfig {
    interfaceImplementationsToExclude: Array<InterfaceTypeRid>;
    interfaceLinkImplementationsToExclude: Array<ObjectTypeInterfaceLinkImplementation>;
}
type ObjectTypePropertyReference = BlockInternalId;
type ObjectTypeReference = BlockInternalId;
/**
 * An ObjectTypeReferenceType can be used to supply an object type to a function. This is useful for
 * addInterfaceRule where you need to specify what type of object you're creating.
 * NOTE: this is NOT an object instance.
 */
interface ObjectTypeReferenceType {
}
/**
 * An ObjectTypeRid was referenced for which the shape id could not be resolved. This is typical if the
 * referenced ObjectType has not been included as an input/output in the block.
 */
interface ObjectTypeReferenceUnresolvable {
    actual: ObjectTypeRid;
    expected: ObjectTypeReference;
}
type ObjectTypeRid = string;
/**
 * Not yet implemented by the corresponding service
 */
interface ObjectViewCreateBlockRequest {
    editHistoryVersion?: number | null | undefined;
    objectTypeRid: string;
    profiles: Array<MultipassGroupId>;
    tabIds: Array<ObjectViewTabId>;
}
interface ObjectViewIdentifier {
    objectTypeRid: ObjectTypeRid;
}
interface ObjectViewOutputSpecConfig {
    tabConfig?: ObjectViewTabConfig | null | undefined;
}
type ObjectViewReference = BlockInternalId;
interface ObjectViewShape {
    about: LocalizedTitleAndDescription;
    objectType: ObjectTypeReference;
    tabs: Array<ObjectViewTabReference>;
}
interface ObjectViewTabConfig {
    tabsIds: Array<ObjectViewTabId>;
}
type ObjectViewTabId = string;
interface ObjectViewTabIdentifier {
    objectTypeRid: ObjectTypeRid;
    tabId: ObjectViewTabId;
}
type ObjectViewTabReference = BlockInternalId;
interface ObjectViewTabShape {
    about: LocalizedTitleAndDescription;
    objectView: ObjectViewReference;
}
interface ObjFormat {
}
interface OciLocator {
    name: string;
    tagOrDigest: TagOrDigest;
}
interface OggAudioContainerFormat_singleStream {
    type: "singleStream";
    singleStream: SingleStreamOggAudioContainerFormat;
}
/**
 * An audio-only ogg container.
 * See https://xiph.org/ogg/doc/oggstream.html
 */
type OggAudioContainerFormat = OggAudioContainerFormat_singleStream;
interface OggAudioFormat_opus {
    type: "opus";
    opus: OpusFormat;
}
interface OggAudioFormat_vorbis {
    type: "vorbis";
    vorbis: VorbisFormat;
}
type OggAudioFormat = OggAudioFormat_opus | OggAudioFormat_vorbis;
/**
 * No resolved shape was specified, even though there are preset values on the shape. Optional shapes with
 * presets are unsupported.
 */
interface OmittedShapeForShapeWithPresets {
}
/**
 * This hint can be used to inform consumers whether the number of links on the many side of a
 * OneToManyLinkDefinition is intended to be one or more.
 */
type OneToManyLinkCardinalityHint = "ONE_TO_ONE" | "ONE_TO_MANY";
interface OneToManyLinkTypeApiNames {
    manyToOneApiName: ObjectTypeFieldApiName;
    oneToManyApiName: ObjectTypeFieldApiName;
}
type OntologyBoundFunctionApiName = string;
interface OntologyBoundFunctionApiNameAndBinding {
    apiName: OntologyBoundFunctionApiName;
    ontologyBinding: OntologyRid;
}
interface OntologyContext {
    ontologyRid: OntologyRid;
}
interface OntologyCreateBlockRequest {
    actionTypeRids: Array<string>;
    interfaceImplementationsToExclude: Record<ObjectTypeRid, Array<InterfaceTypeRid>>;
    interfaceLinkImplementationsToExclude: Record<ObjectTypeRid, Array<ObjectTypeInterfaceLinkImplementation>>;
    interfaceTypeRids: Array<string>;
    linkTypeRids: Array<string>;
    materializationBehavior?: MaterializationBehavior | null | undefined;
    objectTypeRids: Array<string>;
    ontologyVersion?: string | null | undefined;
    sharedPropertyTypeRids: Array<string>;
    targetEnvironment?: TargetEnvironment | null | undefined;
}
interface OntologyDatasourceIdentifier {
    datasourceRid: string;
    ontologyEntityRid: string;
}
/**
 * The Ontology entity has no datasource with this RID.
 */
interface OntologyDatasourceMissingFromEntity {
    datasourceRid: string;
    ontologyEntityRid: string;
}
interface OntologyDatasourceNotFound {
    datasourceRid: string;
    ontologyEntityRid: string;
}
interface OntologyDatasourceRetentionShape {
    about: LocalizedTitleAndDescription;
    id: StableShapeIdentifier;
}
interface OntologyDatasourceShape {
    about: LocalizedTitleAndDescription;
    ontologyEntity: OntologyEntityReference;
}
/**
 * The Ontology entity for a resolved input or output shape was not in the target Ontology.
 */
interface OntologyEntityNotInTargetOntology {
    actualOntologyRid: OntologyRid;
    entityRid: string;
    expectedOntologyRid: OntologyRid;
}
interface OntologyEntityReference_objectType {
    type: "objectType";
    objectType: ObjectTypeReference;
}
interface OntologyEntityReference_manyToManyLinkType {
    type: "manyToManyLinkType";
    manyToManyLinkType: LinkTypeReference;
}
type OntologyEntityReference = OntologyEntityReference_objectType | OntologyEntityReference_manyToManyLinkType;
/**
 * The location to install ontology resources. In the future we might add things like branch etc.
 */
interface OntologyInstallLocation {
    ontologyRid: OntologyRid;
    projectAssociation?: OntologyProjectAssociation | null | undefined;
    useOntologyPackage?: boolean | null | undefined;
}
/**
 * A block with Ontology inputs and/or outputs was requested to be installed, but no Ontology install location
 * was defined in the request.
 */
interface OntologyInstallLocationNotDefined {
}
interface OntologyInterfaceTypeNotFound {
    interfaceTypeRid?: InterfaceTypeRid | null | undefined;
}
/**
 * OntologyInstallLocation.useOntologyPackage was set to true, but the passed OntologyRid is the default
 * Ontology's Rid which is not allowed.
 */
interface OntologyPackageInDefaultOntologyNotAllowed {
}
interface OntologyProjectAssociation_useProject {
    type: "useProject";
    useProject: Void;
}
interface OntologyProjectAssociation_useOntologyPackage {
    type: "useOntologyPackage";
    useOntologyPackage: Void;
}
type OntologyProjectAssociation = OntologyProjectAssociation_useProject | OntologyProjectAssociation_useOntologyPackage;
type OntologyRid = string;
interface OntologySdkCreateBlockRequest {
    ontologySdkRid: string;
    ontologySdkVersion?: string | null | undefined;
}
/**
 * This type is being deprecated in favor of the V1 type with an optional version.
 */
interface OntologySdkCreateBlockRequestV2 {
    packageName: string;
    repositoryRid: string;
}
interface OntologySdkEntityIdentifier {
    rid: OntologySdkRid;
    version?: OntologySdkVersion | null | undefined;
}
interface OntologySdkIdentifier {
    packageName: string;
    repositoryRid: ArtifactsRepositoryRid;
}
type OntologySdkRid = string;
interface OntologySdkShape {
    about: LocalizedTitleAndDescription;
}
interface OntologySdkShapeV2 {
    about: LocalizedTitleAndDescription;
}
interface OntologySdkV2EntityIdentifier {
    packageName: PackageName;
    repositoryRid: ArtifactsRepositoryRid;
}
type OntologySdkVersion = string;
type OntologyVersion = string;
interface OpusFormat {
}
/**
 * A mirror of com.palantir.apollo.maven.api.OrderableMavenCoordinate.
 */
interface OrderableMavenCoordinate {
    orderableSlsVersion: string;
    productId: MavenProductId;
}
/**
 * Logical OR - destination function must satisfy AT LEAST ONE nested expression.
 */
interface OrExpressionIdentifier {
    expressions: Array<ContractExpressionIdentifier>;
}
type OrganizationRid = string;
interface OtherStoreLocalRecommendationSource {
    marketplaceRid: MarketplaceRid;
}
interface OtherValidationFailure {
    errorMessage: string;
}
interface OutputBlockSetMappingInfo {
    backingShape: ShapeReference;
    producedByBlockType: BlockType;
    resolvedShape: ResolvedBlockSetOutputShape;
    shape: BlockSetOutputShape;
}
type OutputBlockSetShapeId = BlockSetShapeId;
type OutputEditsSupport = "EDITS_ENABLED" | "EDITS_DISABLED";
/**
 * The resolved edits support of the provided ObjectType does not match the packaged resource.
 */
interface OutputEditsSupportMismatch {
    actual: OutputEditsSupport;
    expected: OutputEditsSupport;
}
interface OutputEntityIdentifier_action {
    type: "action";
    action: ActionTypeIdentifier;
}
interface OutputEntityIdentifier_actionParameter {
    type: "actionParameter";
    actionParameter: ActionTypeParameterIdentifier;
}
interface OutputEntityIdentifier_aipAgent {
    type: "aipAgent";
    aipAgent: AipAgentIdentifier;
}
interface OutputEntityIdentifier_appConfigTitanium {
    type: "appConfigTitanium";
    appConfigTitanium: AppConfigIdentifier;
}
interface OutputEntityIdentifier_appConfig {
    type: "appConfig";
    appConfig: AppConfigIdentifier;
}
interface OutputEntityIdentifier_artifactsRepository {
    type: "artifactsRepository";
    artifactsRepository: ArtifactsRepositoryIdentifier;
}
interface OutputEntityIdentifier_authoringLibrary {
    type: "authoringLibrary";
    authoringLibrary: AuthoringLibraryIdentifier;
}
interface OutputEntityIdentifier_authoringRepository {
    type: "authoringRepository";
    authoringRepository: AuthoringRepositoryIdentifier;
}
interface OutputEntityIdentifier_automation {
    type: "automation";
    automation: AutomationIdentifier;
}
interface OutputEntityIdentifier_autopilotWorkbench {
    type: "autopilotWorkbench";
    autopilotWorkbench: AutopilotWorkbenchIdentifier;
}
interface OutputEntityIdentifier_blobster {
    type: "blobster";
    blobster: BlobsterOutputIdentifier;
}
interface OutputEntityIdentifier_carbonWorkspace {
    type: "carbonWorkspace";
    carbonWorkspace: CarbonWorkspaceIdentifier;
}
interface OutputEntityIdentifier_checkpointConfig {
    type: "checkpointConfig";
    checkpointConfig: CheckpointConfigEntityIdentifier;
}
interface OutputEntityIdentifier_cipherChannel {
    type: "cipherChannel";
    cipherChannel: CipherChannelEntityIdentifier;
}
interface OutputEntityIdentifier_cipherLicense {
    type: "cipherLicense";
    cipherLicense: CipherLicenseEntityIdentifier;
}
interface OutputEntityIdentifier_codeWorkspace {
    type: "codeWorkspace";
    codeWorkspace: CodeWorkspaceIdentifier;
}
interface OutputEntityIdentifier_compassResource {
    type: "compassResource";
    compassResource: CompassResourceOutputIdentifier;
}
interface OutputEntityIdentifier_contourAnalysis {
    type: "contourAnalysis";
    contourAnalysis: ContourAnalysisEntityIdentifier;
}
interface OutputEntityIdentifier_contourRef {
    type: "contourRef";
    contourRef: ContourRefEntityIdentifier;
}
interface OutputEntityIdentifier_dataHealthCheck {
    type: "dataHealthCheck";
    dataHealthCheck: DataHealthCheckIdentifier;
}
interface OutputEntityIdentifier_dataHealthCheckGroup {
    type: "dataHealthCheckGroup";
    dataHealthCheckGroup: DataHealthCheckGroupIdentifier;
}
interface OutputEntityIdentifier_deployedApp {
    type: "deployedApp";
    deployedApp: DeployedAppIdentifier;
}
interface OutputEntityIdentifier_datasourceColumn {
    type: "datasourceColumn";
    datasourceColumn: DatasourceColumnIdentifier;
}
interface OutputEntityIdentifier_eddieEdgePipeline {
    type: "eddieEdgePipeline";
    eddieEdgePipeline: EddieEdgePipelineIdentifier;
}
interface OutputEntityIdentifier_eddiePipeline {
    type: "eddiePipeline";
    eddiePipeline: EddiePipelineIdentifier;
}
interface OutputEntityIdentifier_evaluationSuite {
    type: "evaluationSuite";
    evaluationSuite: EvaluationSuiteIdentifier;
}
interface OutputEntityIdentifier_filesDatasource {
    type: "filesDatasource";
    filesDatasource: FilesDatasourceOutputIdentifier;
}
interface OutputEntityIdentifier_function {
    type: "function";
    function: FunctionOutputIdentifier;
}
interface OutputEntityIdentifier_functionConfiguration {
    type: "functionConfiguration";
    functionConfiguration: FunctionConfigurationIdentifier;
}
interface OutputEntityIdentifier_functionPackageConfiguration {
    type: "functionPackageConfiguration";
    functionPackageConfiguration: FunctionPackageConfigurationIdentifier;
}
interface OutputEntityIdentifier_geotimeSeriesIntegration {
    type: "geotimeSeriesIntegration";
    geotimeSeriesIntegration: GeotimeSeriesIntegrationRid;
}
interface OutputEntityIdentifier_interfaceType {
    type: "interfaceType";
    interfaceType: InterfaceTypeIdentifier;
}
interface OutputEntityIdentifier_interfaceLinkType {
    type: "interfaceLinkType";
    interfaceLinkType: InterfaceLinkTypeIdentifier;
}
interface OutputEntityIdentifier_interfacePropertyType {
    type: "interfacePropertyType";
    interfacePropertyType: InterfacePropertyTypeIdentifier;
}
interface OutputEntityIdentifier_interfaceActionTypeConstraint {
    type: "interfaceActionTypeConstraint";
    interfaceActionTypeConstraint: InterfaceActionTypeConstraintIdentifier;
}
interface OutputEntityIdentifier_interfaceParameterConstraint {
    type: "interfaceParameterConstraint";
    interfaceParameterConstraint: InterfaceParameterConstraintIdentifier;
}
interface OutputEntityIdentifier_link {
    type: "link";
    link: OutputLinkTypeIdentifier;
}
interface OutputEntityIdentifier_logic {
    type: "logic";
    logic: LogicIdentifier;
}
interface OutputEntityIdentifier_logicFunction {
    type: "logicFunction";
    logicFunction: LogicFunctionIdentifier;
}
interface OutputEntityIdentifier_machinery {
    type: "machinery";
    machinery: MachineryProcessIdentifier;
}
interface OutputEntityIdentifier_magritteExtract {
    type: "magritteExtract";
    magritteExtract: LegacyNotImplementedIdentifier;
}
interface OutputEntityIdentifier_magritteExport {
    type: "magritteExport";
    magritteExport: MagritteExportIdentifier;
}
interface OutputEntityIdentifier_magritteSource {
    type: "magritteSource";
    magritteSource: MagritteSourceIdentifier;
}
interface OutputEntityIdentifier_magritteStreamingExtract {
    type: "magritteStreamingExtract";
    magritteStreamingExtract: LegacyNotImplementedIdentifier;
}
interface OutputEntityIdentifier_modelStudio {
    type: "modelStudio";
    modelStudio: ModelStudioIdentifier;
}
interface OutputEntityIdentifier_modelStudioConfig {
    type: "modelStudioConfig";
    modelStudioConfig: ModelStudioConfigIdentifier;
}
interface OutputEntityIdentifier_model {
    type: "model";
    model: ModelOutputIdentifier;
}
interface OutputEntityIdentifier_monitor {
    type: "monitor";
    monitor: MonitorIdentifier;
}
interface OutputEntityIdentifier_monitorView {
    type: "monitorView";
    monitorView: MonitorViewIdentifier;
}
interface OutputEntityIdentifier_mapRendererSet {
    type: "mapRendererSet";
    mapRendererSet: MapRendererSetIdentifier;
}
interface OutputEntityIdentifier_mapRendererSetV2 {
    type: "mapRendererSetV2";
    mapRendererSetV2: MapRendererSetIdentifierV2;
}
interface OutputEntityIdentifier_namedCredential {
    type: "namedCredential";
    namedCredential: NamedCredentialIdentifier;
}
interface OutputEntityIdentifier_networkEgressPolicy {
    type: "networkEgressPolicy";
    networkEgressPolicy: NetworkEgressPolicyIdentifier;
}
interface OutputEntityIdentifier_normalizationMaxClassification {
    type: "normalizationMaxClassification";
    normalizationMaxClassification: NormalizationMaxClassificationIdentifier;
}
interface OutputEntityIdentifier_notepadDocument {
    type: "notepadDocument";
    notepadDocument: NotepadPartialResolvedShape;
}
interface OutputEntityIdentifier_notepadTemplate {
    type: "notepadTemplate";
    notepadTemplate: NotepadTemplateIdentifier;
}
interface OutputEntityIdentifier_notepadTemplateParameter {
    type: "notepadTemplateParameter";
    notepadTemplateParameter: NotepadTemplateParameterIdentifier;
}
interface OutputEntityIdentifier_objectSet {
    type: "objectSet";
    objectSet: ObjectSetIdentifier;
}
interface OutputEntityIdentifier_objectType {
    type: "objectType";
    objectType: OutputObjectTypeIdentifier;
}
interface OutputEntityIdentifier_objectView {
    type: "objectView";
    objectView: ObjectViewIdentifier;
}
interface OutputEntityIdentifier_objectViewTab {
    type: "objectViewTab";
    objectViewTab: ObjectViewTabIdentifier;
}
interface OutputEntityIdentifier_ontologySdk {
    type: "ontologySdk";
    ontologySdk: OntologySdkEntityIdentifier;
}
interface OutputEntityIdentifier_ontologySdkV2 {
    type: "ontologySdkV2";
    ontologySdkV2: OntologySdkV2EntityIdentifier;
}
interface OutputEntityIdentifier_ontologyDatasource {
    type: "ontologyDatasource";
    ontologyDatasource: OntologyDatasourceIdentifier;
}
interface OutputEntityIdentifier_peerProducerProfile {
    type: "peerProducerProfile";
    peerProducerProfile: PeerProducerProfileIdentifier;
}
interface OutputEntityIdentifier_peerProfile {
    type: "peerProfile";
    peerProfile: PeerProfileIdentifier;
}
interface OutputEntityIdentifier_property {
    type: "property";
    property: PropertyIdentifier;
}
interface OutputEntityIdentifier_quiverDashboard {
    type: "quiverDashboard";
    quiverDashboard: QuiverDashboardIdentifier;
}
interface OutputEntityIdentifier_resourceUpdatesContent {
    type: "resourceUpdatesContent";
    resourceUpdatesContent: ResourceUpdatesContentIdentifier;
}
interface OutputEntityIdentifier_rosettaDocsBundle {
    type: "rosettaDocsBundle";
    rosettaDocsBundle: RosettaDocsBundleIdentifier;
}
interface OutputEntityIdentifier_savedSearchAroundV2 {
    type: "savedSearchAroundV2";
    savedSearchAroundV2: SavedSearchAroundV2OutputIdentifier;
}
interface OutputEntityIdentifier_schedule {
    type: "schedule";
    schedule: ScheduleIdentifier;
}
interface OutputEntityIdentifier_sharedPropertyType {
    type: "sharedPropertyType";
    sharedPropertyType: SharedPropertyTypeIdentifier;
}
interface OutputEntityIdentifier_slateApplication {
    type: "slateApplication";
    slateApplication: SlateApplicationIdentifier;
}
interface OutputEntityIdentifier_storedProcedure {
    type: "storedProcedure";
    storedProcedure: StoredProcedureEntityIdentifier;
}
interface OutputEntityIdentifier_solutionDesign {
    type: "solutionDesign";
    solutionDesign: SolutionDesignIdentifier;
}
interface OutputEntityIdentifier_tabularDatasource {
    type: "tabularDatasource";
    tabularDatasource: TabularDatasourceOutputIdentifier;
}
interface OutputEntityIdentifier_taurusWorkflow {
    type: "taurusWorkflow";
    taurusWorkflow: TaurusWorkflowIdentifier;
}
interface OutputEntityIdentifier_thirdPartyApplication {
    type: "thirdPartyApplication";
    thirdPartyApplication: ThirdPartyApplicationEntityIdentifier;
}
interface OutputEntityIdentifier_timeSeriesSync {
    type: "timeSeriesSync";
    timeSeriesSync: TimeSeriesSyncRid;
}
interface OutputEntityIdentifier_transformsJobSpec {
    type: "transformsJobSpec";
    transformsJobSpec: LegacyNotImplementedIdentifier;
}
interface OutputEntityIdentifier_valueType {
    type: "valueType";
    valueType: VersionedValueTypeIdentifier;
}
interface OutputEntityIdentifier_versionedObjectSet {
    type: "versionedObjectSet";
    versionedObjectSet: VersionedObjectSetEntityIdentifier;
}
interface OutputEntityIdentifier_vertexTemplate {
    type: "vertexTemplate";
    vertexTemplate: VertexEntityIdentifier;
}
interface OutputEntityIdentifier_vortexTemplate {
    type: "vortexTemplate";
    vortexTemplate: VortexEntityIdentifier;
}
interface OutputEntityIdentifier_walkthrough {
    type: "walkthrough";
    walkthrough: WalkthroughEntityIdentifier;
}
interface OutputEntityIdentifier_webhook {
    type: "webhook";
    webhook: WebhookEntityIdentifier;
}
interface OutputEntityIdentifier_widget {
    type: "widget";
    widget: WidgetIdentifier;
}
interface OutputEntityIdentifier_widgetSet {
    type: "widgetSet";
    widgetSet: WidgetSetIdentifier;
}
interface OutputEntityIdentifier_workbenchTemplate {
    type: "workbenchTemplate";
    workbenchTemplate: WorkbenchTemplateIdentifier;
}
interface OutputEntityIdentifier_workflowBuilderGraph {
    type: "workflowBuilderGraph";
    workflowBuilderGraph: WorkflowBuilderGraphIdentifier;
}
interface OutputEntityIdentifier_workflowGraph {
    type: "workflowGraph";
    workflowGraph: WorkflowGraphIdentifier;
}
interface OutputEntityIdentifier_sqlWorksheet {
    type: "sqlWorksheet";
    sqlWorksheet: SqlWorksheetEntityIdentifier;
}
interface OutputEntityIdentifier_workshop {
    type: "workshop";
    workshop: WorkshopIdentifier;
}
type OutputEntityIdentifier = OutputEntityIdentifier_action | OutputEntityIdentifier_actionParameter | OutputEntityIdentifier_aipAgent | OutputEntityIdentifier_appConfigTitanium | OutputEntityIdentifier_appConfig | OutputEntityIdentifier_artifactsRepository | OutputEntityIdentifier_authoringLibrary | OutputEntityIdentifier_authoringRepository | OutputEntityIdentifier_automation | OutputEntityIdentifier_autopilotWorkbench | OutputEntityIdentifier_blobster | OutputEntityIdentifier_carbonWorkspace | OutputEntityIdentifier_checkpointConfig | OutputEntityIdentifier_cipherChannel | OutputEntityIdentifier_cipherLicense | OutputEntityIdentifier_codeWorkspace | OutputEntityIdentifier_compassResource | OutputEntityIdentifier_contourAnalysis | OutputEntityIdentifier_contourRef | OutputEntityIdentifier_dataHealthCheck | OutputEntityIdentifier_dataHealthCheckGroup | OutputEntityIdentifier_deployedApp | OutputEntityIdentifier_datasourceColumn | OutputEntityIdentifier_eddieEdgePipeline | OutputEntityIdentifier_eddiePipeline | OutputEntityIdentifier_evaluationSuite | OutputEntityIdentifier_filesDatasource | OutputEntityIdentifier_function | OutputEntityIdentifier_functionConfiguration | OutputEntityIdentifier_functionPackageConfiguration | OutputEntityIdentifier_geotimeSeriesIntegration | OutputEntityIdentifier_interfaceType | OutputEntityIdentifier_interfaceLinkType | OutputEntityIdentifier_interfacePropertyType | OutputEntityIdentifier_interfaceActionTypeConstraint | OutputEntityIdentifier_interfaceParameterConstraint | OutputEntityIdentifier_link | OutputEntityIdentifier_logic | OutputEntityIdentifier_logicFunction | OutputEntityIdentifier_machinery | OutputEntityIdentifier_magritteExtract | OutputEntityIdentifier_magritteExport | OutputEntityIdentifier_magritteSource | OutputEntityIdentifier_magritteStreamingExtract | OutputEntityIdentifier_modelStudio | OutputEntityIdentifier_modelStudioConfig | OutputEntityIdentifier_model | OutputEntityIdentifier_monitor | OutputEntityIdentifier_monitorView | OutputEntityIdentifier_mapRendererSet | OutputEntityIdentifier_mapRendererSetV2 | OutputEntityIdentifier_namedCredential | OutputEntityIdentifier_networkEgressPolicy | OutputEntityIdentifier_normalizationMaxClassification | OutputEntityIdentifier_notepadDocument | OutputEntityIdentifier_notepadTemplate | OutputEntityIdentifier_notepadTemplateParameter | OutputEntityIdentifier_objectSet | OutputEntityIdentifier_objectType | OutputEntityIdentifier_objectView | OutputEntityIdentifier_objectViewTab | OutputEntityIdentifier_ontologySdk | OutputEntityIdentifier_ontologySdkV2 | OutputEntityIdentifier_ontologyDatasource | OutputEntityIdentifier_peerProducerProfile | OutputEntityIdentifier_peerProfile | OutputEntityIdentifier_property | OutputEntityIdentifier_quiverDashboard | OutputEntityIdentifier_resourceUpdatesContent | OutputEntityIdentifier_rosettaDocsBundle | OutputEntityIdentifier_savedSearchAroundV2 | OutputEntityIdentifier_schedule | OutputEntityIdentifier_sharedPropertyType | OutputEntityIdentifier_slateApplication | OutputEntityIdentifier_storedProcedure | OutputEntityIdentifier_solutionDesign | OutputEntityIdentifier_tabularDatasource | OutputEntityIdentifier_taurusWorkflow | OutputEntityIdentifier_thirdPartyApplication | OutputEntityIdentifier_timeSeriesSync | OutputEntityIdentifier_transformsJobSpec | OutputEntityIdentifier_valueType | OutputEntityIdentifier_versionedObjectSet | OutputEntityIdentifier_vertexTemplate | OutputEntityIdentifier_vortexTemplate | OutputEntityIdentifier_walkthrough | OutputEntityIdentifier_webhook | OutputEntityIdentifier_widget | OutputEntityIdentifier_widgetSet | OutputEntityIdentifier_workbenchTemplate | OutputEntityIdentifier_workflowBuilderGraph | OutputEntityIdentifier_workflowGraph | OutputEntityIdentifier_sqlWorksheet | OutputEntityIdentifier_workshop;
interface OutputLinkTypeIdentifier {
    identifier: LinkTypeIdentifier;
}
type OutputObjectBackendVersion = "V1" | "V2";
/**
 * The objects backend support of the provided ObjectType does not match the packaged resource.
 */
interface OutputObjectsBackendMismatch {
    actual: OutputObjectBackendVersion;
    expected: OutputObjectBackendVersion;
}
interface OutputObjectTypeIdentifier {
    identifier: ObjectTypeIdentifier;
}
/**
 * A resolved output from this installation is already by another installation. This can happen if an output from
 * one installation is attached to another installation. As of writing, this is just treated as a warning, and
 * the user can decide to proceed with the installation if they want to, effectively attaching the outputs back
 * to the current installation.
 */
interface OutputOwnedByAnotherInstallation {
    blockInstallationRid: BlockInstallationRid;
    blockSetBlockInstanceId: BlockSetBlockInstanceId;
    blockSetInstallationRid: BlockSetInstallationRid;
    blockShapeId: BlockShapeId;
    blockVersionId: BlockVersionId;
}
/**
 * Refers to an output shape of some block. The block reference is valid in the context of this install request.
 * That is, it may be a concrete BlockInstallationRid (where the shape id is only guaranteed to exist after
 * any upgrades on that block installation have happened) or via referring to the output of a block which
 * is to be newly installed as part of this request.
 */
interface OutputReference {
    blockReference: BlockReference;
    outputId: BlockShapeId;
}
interface OutputShape_action {
    type: "action";
    action: ActionTypeShape;
}
interface OutputShape_actionParameter {
    type: "actionParameter";
    actionParameter: ActionTypeParameterShape;
}
interface OutputShape_aipAgent {
    type: "aipAgent";
    aipAgent: AipAgentShape;
}
interface OutputShape_appConfigTitanium {
    type: "appConfigTitanium";
    appConfigTitanium: AppConfigOutputShape;
}
interface OutputShape_appConfig {
    type: "appConfig";
    appConfig: AppConfigOutputShape;
}
interface OutputShape_artifactsRepository {
    type: "artifactsRepository";
    artifactsRepository: ArtifactsRepositoryShape;
}
interface OutputShape_authoringLibrary {
    type: "authoringLibrary";
    authoringLibrary: AuthoringLibraryShape;
}
interface OutputShape_authoringRepository {
    type: "authoringRepository";
    authoringRepository: AuthoringRepositoryShape;
}
interface OutputShape_automation {
    type: "automation";
    automation: AutomationShape;
}
interface OutputShape_autopilotWorkbench {
    type: "autopilotWorkbench";
    autopilotWorkbench: AutopilotWorkbenchShape;
}
interface OutputShape_blobsterResource {
    type: "blobsterResource";
    blobsterResource: BlobsterResourceOutputShape;
}
interface OutputShape_carbonWorkspace {
    type: "carbonWorkspace";
    carbonWorkspace: CarbonWorkspaceOutputShape;
}
interface OutputShape_checkpointConfig {
    type: "checkpointConfig";
    checkpointConfig: CheckpointConfigOutputShape;
}
interface OutputShape_cipherChannel {
    type: "cipherChannel";
    cipherChannel: CipherChannelOutputShape;
}
interface OutputShape_cipherLicense {
    type: "cipherLicense";
    cipherLicense: CipherLicenseOutputShape;
}
interface OutputShape_codeWorkspace {
    type: "codeWorkspace";
    codeWorkspace: CodeWorkspaceOutputShape;
}
interface OutputShape_compassResource {
    type: "compassResource";
    compassResource: CompassResourceOutputShape;
}
interface OutputShape_contourAnalysis {
    type: "contourAnalysis";
    contourAnalysis: ContourAnalysisShape;
}
interface OutputShape_contourRef {
    type: "contourRef";
    contourRef: ContourRefShape;
}
interface OutputShape_dataHealthCheck {
    type: "dataHealthCheck";
    dataHealthCheck: DataHealthCheckShape;
}
interface OutputShape_dataHealthCheckGroup {
    type: "dataHealthCheckGroup";
    dataHealthCheckGroup: DataHealthCheckGroupShape;
}
interface OutputShape_deployedApp {
    type: "deployedApp";
    deployedApp: DeployedAppShape;
}
interface OutputShape_datasourceColumn {
    type: "datasourceColumn";
    datasourceColumn: DatasourceColumnShape;
}
interface OutputShape_eddieEdgePipeline {
    type: "eddieEdgePipeline";
    eddieEdgePipeline: EddieEdgePipelineOutputShape;
}
interface OutputShape_eddiePipeline {
    type: "eddiePipeline";
    eddiePipeline: EddiePipelineShape;
}
interface OutputShape_evaluationSuite {
    type: "evaluationSuite";
    evaluationSuite: EvaluationSuiteShape;
}
interface OutputShape_filesDatasource {
    type: "filesDatasource";
    filesDatasource: FilesDatasourceOutputShape;
}
interface OutputShape_function {
    type: "function";
    function: FunctionOutputShape;
}
interface OutputShape_functionConfiguration {
    type: "functionConfiguration";
    functionConfiguration: FunctionConfigurationShape;
}
interface OutputShape_functionPackageConfiguration {
    type: "functionPackageConfiguration";
    functionPackageConfiguration: FunctionPackageConfigurationShape;
}
interface OutputShape_geotimeSeriesIntegration {
    type: "geotimeSeriesIntegration";
    geotimeSeriesIntegration: GeotimeSeriesIntegrationShape;
}
interface OutputShape_interfaceType {
    type: "interfaceType";
    interfaceType: InterfaceTypeOutputShape;
}
interface OutputShape_interfaceLinkType {
    type: "interfaceLinkType";
    interfaceLinkType: InterfaceLinkTypeOutputShape;
}
interface OutputShape_interfacePropertyType {
    type: "interfacePropertyType";
    interfacePropertyType: InterfacePropertyTypeOutputShape;
}
interface OutputShape_interfaceActionTypeConstraint {
    type: "interfaceActionTypeConstraint";
    interfaceActionTypeConstraint: InterfaceActionTypeConstraintShape;
}
interface OutputShape_interfaceParameterConstraint {
    type: "interfaceParameterConstraint";
    interfaceParameterConstraint: InterfaceParameterConstraintShape;
}
interface OutputShape_linkType {
    type: "linkType";
    linkType: LinkTypeOutputShape;
}
interface OutputShape_logic {
    type: "logic";
    logic: LogicShape;
}
interface OutputShape_logicFunction {
    type: "logicFunction";
    logicFunction: LogicFunctionShape;
}
interface OutputShape_machinery {
    type: "machinery";
    machinery: MachineryProcessShape;
}
interface OutputShape_magritteExport {
    type: "magritteExport";
    magritteExport: MagritteExportShape;
}
interface OutputShape_magritteExtract {
    type: "magritteExtract";
    magritteExtract: MagritteExtractOutputShape;
}
interface OutputShape_magritteSource {
    type: "magritteSource";
    magritteSource: MagritteSourceOutputShape;
}
interface OutputShape_magritteStreamingExtract {
    type: "magritteStreamingExtract";
    magritteStreamingExtract: MagritteStreamingExtractOutputShape;
}
interface OutputShape_modelStudio {
    type: "modelStudio";
    modelStudio: ModelStudioOutputShape;
}
interface OutputShape_modelStudioConfig {
    type: "modelStudioConfig";
    modelStudioConfig: ModelStudioConfigShape;
}
interface OutputShape_model {
    type: "model";
    model: ModelOutputShape;
}
interface OutputShape_monitor {
    type: "monitor";
    monitor: MonitorShape;
}
interface OutputShape_monitorView {
    type: "monitorView";
    monitorView: MonitorViewShape;
}
interface OutputShape_mapRendererSet {
    type: "mapRendererSet";
    mapRendererSet: MapRendererSetOutputShape;
}
interface OutputShape_mapRendererSetV2 {
    type: "mapRendererSetV2";
    mapRendererSetV2: MapRendererSetOutputShapeV2;
}
interface OutputShape_namedCredential {
    type: "namedCredential";
    namedCredential: NamedCredentialShape;
}
interface OutputShape_networkEgressPolicy {
    type: "networkEgressPolicy";
    networkEgressPolicy: NetworkEgressPolicyShape;
}
interface OutputShape_normalizationMaxClassification {
    type: "normalizationMaxClassification";
    normalizationMaxClassification: NormalizationMaxClassificationOutputShape;
}
interface OutputShape_notepadDocument {
    type: "notepadDocument";
    notepadDocument: NotepadDocumentShape;
}
interface OutputShape_notepadTemplate {
    type: "notepadTemplate";
    notepadTemplate: NotepadTemplateShape;
}
interface OutputShape_notepadTemplateParameter {
    type: "notepadTemplateParameter";
    notepadTemplateParameter: NotepadTemplateParameterShape;
}
interface OutputShape_objectSet {
    type: "objectSet";
    objectSet: ObjectSetShape;
}
interface OutputShape_objectType {
    type: "objectType";
    objectType: ObjectTypeOutputShape;
}
interface OutputShape_objectView {
    type: "objectView";
    objectView: ObjectViewShape;
}
interface OutputShape_objectViewTab {
    type: "objectViewTab";
    objectViewTab: ObjectViewTabShape;
}
interface OutputShape_ontologyDatasource {
    type: "ontologyDatasource";
    ontologyDatasource: OntologyDatasourceShape;
}
interface OutputShape_peerProducerProfile {
    type: "peerProducerProfile";
    peerProducerProfile: PeerProducerProfileShape;
}
interface OutputShape_peerProfile {
    type: "peerProfile";
    peerProfile: PeerProfileShape;
}
interface OutputShape_property {
    type: "property";
    property: PropertyOutputShape;
}
interface OutputShape_quiverDashboard {
    type: "quiverDashboard";
    quiverDashboard: QuiverDashboardShape;
}
interface OutputShape_resourceUpdatesContent {
    type: "resourceUpdatesContent";
    resourceUpdatesContent: ResourceUpdatesContentOutputShape;
}
interface OutputShape_rosettaDocsBundle {
    type: "rosettaDocsBundle";
    rosettaDocsBundle: RosettaDocsBundleShape;
}
interface OutputShape_savedSearchAroundV2 {
    type: "savedSearchAroundV2";
    savedSearchAroundV2: SavedSearchAroundV2OutputShape;
}
interface OutputShape_ontologySdk {
    type: "ontologySdk";
    ontologySdk: OntologySdkShape;
}
interface OutputShape_ontologySdkV2 {
    type: "ontologySdkV2";
    ontologySdkV2: OntologySdkShapeV2;
}
interface OutputShape_schedule {
    type: "schedule";
    schedule: ScheduleShape;
}
interface OutputShape_sharedPropertyType {
    type: "sharedPropertyType";
    sharedPropertyType: SharedPropertyTypeOutputShape;
}
interface OutputShape_slateApplication {
    type: "slateApplication";
    slateApplication: SlateApplicationOutputShape;
}
interface OutputShape_storedProcedure {
    type: "storedProcedure";
    storedProcedure: StoredProcedureShape;
}
interface OutputShape_solutionDesign {
    type: "solutionDesign";
    solutionDesign: SolutionDesignShape;
}
interface OutputShape_tabularDatasource {
    type: "tabularDatasource";
    tabularDatasource: TabularDatasourceOutputShape;
}
interface OutputShape_taurusWorkflow {
    type: "taurusWorkflow";
    taurusWorkflow: TaurusWorkflowShape;
}
interface OutputShape_thirdPartyApplication {
    type: "thirdPartyApplication";
    thirdPartyApplication: ThirdPartyApplicationShape;
}
interface OutputShape_timeSeriesSync {
    type: "timeSeriesSync";
    timeSeriesSync: TimeSeriesSyncShape;
}
interface OutputShape_transformsJobSpec {
    type: "transformsJobSpec";
    transformsJobSpec: TransformsJobSpecShape;
}
interface OutputShape_valueType {
    type: "valueType";
    valueType: ValueTypeShape;
}
interface OutputShape_versionedObjectSet {
    type: "versionedObjectSet";
    versionedObjectSet: VersionedObjectSetShape;
}
interface OutputShape_vertexTemplate {
    type: "vertexTemplate";
    vertexTemplate: VertexTemplateShape;
}
interface OutputShape_vortexTemplate {
    type: "vortexTemplate";
    vortexTemplate: VortexTemplateShape;
}
interface OutputShape_walkthrough {
    type: "walkthrough";
    walkthrough: WalkthroughShape;
}
interface OutputShape_webhook {
    type: "webhook";
    webhook: WebhookShape;
}
interface OutputShape_widget {
    type: "widget";
    widget: WidgetShape;
}
interface OutputShape_widgetSet {
    type: "widgetSet";
    widgetSet: WidgetSetShape;
}
interface OutputShape_workbenchTemplate {
    type: "workbenchTemplate";
    workbenchTemplate: WorkbenchTemplateShape;
}
interface OutputShape_workflowBuilderGraph {
    type: "workflowBuilderGraph";
    workflowBuilderGraph: WorkflowBuilderGraphShape;
}
interface OutputShape_workflowGraph {
    type: "workflowGraph";
    workflowGraph: WorkflowGraphShape;
}
interface OutputShape_sqlWorksheet {
    type: "sqlWorksheet";
    sqlWorksheet: SqlWorksheetShape;
}
interface OutputShape_workshopApplication {
    type: "workshopApplication";
    workshopApplication: WorkshopApplicationOutputShape;
}
/**
 * An output must have an about field of type `LocalizedTitleAndDescription`. This is what the FE uses to render
 * the output.
 */
type OutputShape = OutputShape_action | OutputShape_actionParameter | OutputShape_aipAgent | OutputShape_appConfigTitanium | OutputShape_appConfig | OutputShape_artifactsRepository | OutputShape_authoringLibrary | OutputShape_authoringRepository | OutputShape_automation | OutputShape_autopilotWorkbench | OutputShape_blobsterResource | OutputShape_carbonWorkspace | OutputShape_checkpointConfig | OutputShape_cipherChannel | OutputShape_cipherLicense | OutputShape_codeWorkspace | OutputShape_compassResource | OutputShape_contourAnalysis | OutputShape_contourRef | OutputShape_dataHealthCheck | OutputShape_dataHealthCheckGroup | OutputShape_deployedApp | OutputShape_datasourceColumn | OutputShape_eddieEdgePipeline | OutputShape_eddiePipeline | OutputShape_evaluationSuite | OutputShape_filesDatasource | OutputShape_function | OutputShape_functionConfiguration | OutputShape_functionPackageConfiguration | OutputShape_geotimeSeriesIntegration | OutputShape_interfaceType | OutputShape_interfaceLinkType | OutputShape_interfacePropertyType | OutputShape_interfaceActionTypeConstraint | OutputShape_interfaceParameterConstraint | OutputShape_linkType | OutputShape_logic | OutputShape_logicFunction | OutputShape_machinery | OutputShape_magritteExport | OutputShape_magritteExtract | OutputShape_magritteSource | OutputShape_magritteStreamingExtract | OutputShape_modelStudio | OutputShape_modelStudioConfig | OutputShape_model | OutputShape_monitor | OutputShape_monitorView | OutputShape_mapRendererSet | OutputShape_mapRendererSetV2 | OutputShape_namedCredential | OutputShape_networkEgressPolicy | OutputShape_normalizationMaxClassification | OutputShape_notepadDocument | OutputShape_notepadTemplate | OutputShape_notepadTemplateParameter | OutputShape_objectSet | OutputShape_objectType | OutputShape_objectView | OutputShape_objectViewTab | OutputShape_ontologyDatasource | OutputShape_peerProducerProfile | OutputShape_peerProfile | OutputShape_property | OutputShape_quiverDashboard | OutputShape_resourceUpdatesContent | OutputShape_rosettaDocsBundle | OutputShape_savedSearchAroundV2 | OutputShape_ontologySdk | OutputShape_ontologySdkV2 | OutputShape_schedule | OutputShape_sharedPropertyType | OutputShape_slateApplication | OutputShape_storedProcedure | OutputShape_solutionDesign | OutputShape_tabularDatasource | OutputShape_taurusWorkflow | OutputShape_thirdPartyApplication | OutputShape_timeSeriesSync | OutputShape_transformsJobSpec | OutputShape_valueType | OutputShape_versionedObjectSet | OutputShape_vertexTemplate | OutputShape_vortexTemplate | OutputShape_walkthrough | OutputShape_webhook | OutputShape_widget | OutputShape_widgetSet | OutputShape_workbenchTemplate | OutputShape_workflowBuilderGraph | OutputShape_workflowGraph | OutputShape_sqlWorksheet | OutputShape_workshopApplication;
interface OutputShapeCleanupPreview {
    resolvedOutputShape: ResolvedBlockSetOutputShape;
    softDeleteMode: SoftDeleteMode;
}
interface OutputShapeDependencies {
    externallyProvided: Array<InputBlockSetShapeId>;
    internallyRecommended: Array<OutputBlockSetShapeId>;
}
/**
 * Manually overriding block outputs is not supported.
 */
interface OutputShapeOverrideNotSupported {
    shapeId: BlockShapeId;
}
interface OutputShapeResult {
    blockShapeId: BlockShapeId;
    internalShapeId: InternalShapeId;
    resolvedShape: ResolvedOutputShape;
    shape: OutputShape;
}
/**
 * Corresponds 1:1 with the member types of the OutputShape union.
 *
 * NOTE: The name here needs to be identical to the name in `InputShapeType` for the same shape type.
 */
type OutputShapeType = "ACTION" | "ACTION_PARAMETER" | "AIP_AGENT" | "APP_CONFIG" | "APP_CONFIG_TITANIUM" | "ARTIFACTS_REPOSITORY" | "AUTHORING_LIBRARY" | "AUTHORING_REPOSITORY" | "AUTOMATION" | "AUTOPILOT_WORKBENCH" | "BLOBSTER_RESOURCE" | "CARBON_WORKSPACE" | "CHECKPOINT_CONFIG" | "CIPHER_CHANNEL" | "CIPHER_LICENSE" | "CODE_WORKSPACE" | "CONTOUR_ANALYSIS" | "CONTOUR_REF" | "COMPASS_RESOURCE" | "DATA_HEALTH_CHECK" | "DATA_HEALTH_CHECK_GROUP" | "DATASOURCE_COLUMN" | "DEPLOYED_APP" | "EDDIE_EDGE_PIPELINE" | "EDDIE_PIPELINE" | "EVALUATION_SUITE" | "FILES_DATASOURCE" | "FUNCTION" | "FUNCTION_CONFIGURATION" | "FUNCTION_PACKAGE_CONFIGURATION" | "GEOTIME_SERIES_INTEGRATION" | "INTERFACE_TYPE" | "INTERFACE_LINK_TYPE" | "INTERFACE_PROPERTY_TYPE" | "INTERFACE_ACTION_TYPE_CONSTRAINT" | "INTERFACE_PARAMETER_CONSTRAINT" | "LINK_TYPE" | "LOGIC" | "LOGIC_FUNCTION" | "MACHINERY" | "MAGRITTE_EXPORT" | "MAGRITTE_EXTRACT" | "MAGRITTE_STREAMING_EXTRACT" | "MAGRITTE_SOURCE" | "MAP_RENDERER_SET" | "MAP_RENDERER_SET_V2" | "MODEL_STUDIO" | "MODEL_STUDIO_CONFIG" | "MODEL" | "MONITOR" | "MONITOR_VIEW" | "NAMED_CREDENTIAL" | "NETWORK_EGRESS_POLICY" | "NORMALIZATION_MAX_CLASSIFICATION" | "NOTEPAD_DOCUMENT" | "NOTEPAD_TEMPLATE" | "NOTEPAD_TEMPLATE_PARAMETER" | "OBJECT_SET" | "OBJECT_TYPE" | "OBJECT_VIEW" | "OBJECT_VIEW_TAB" | "ONTOLOGY_DATASOURCE" | "PEER_PRODUCER_PROFILE" | "PEER_PROFILE" | "PROPERTY" | "QUIVER_DASHBOARD" | "RESOURCE_UPDATES_CONTENT" | "ROSETTA_DOCS_BUNDLE" | "SCHEDULE" | "SHARED_PROPERTY_TYPE" | "ONTOLOGY_SDK" | "ONTOLOGY_SDK_V2" | "SAVED_SEARCH_AROUND_V2" | "SLATE_APPLICATION" | "STORED_PROCEDURE" | "SOLUTION_DESIGN" | "TABULAR_DATASOURCE" | "TAURUS_WORKFLOW" | "THIRD_PARTY_APPLICATION" | "TIME_SERIES_SYNC" | "TRANSFORMS_JOB_SPEC" | "VALUE_TYPE" | "VERSIONED_OBJECT_SET" | "VERTEX_TEMPLATE" | "VORTEX_TEMPLATE" | "WALKTHROUGH" | "WEBHOOK" | "WIDGET" | "WIDGET_SET" | "WORKBENCH_TEMPLATE" | "WORKFLOW_BUILDER_GRAPH" | "WORKFLOW_GRAPH" | "SQL_WORKSHEET" | "WORKSHOP_APPLICATION";
interface OutputShapeUninstallPreview {
    isInCurrentInstallation: boolean;
    resolvedOutputShape: ResolvedBlockSetOutputShape;
}
/**
 * Representation of an resource with an optional version/config specification that a user wants to package that
 * resource with. After having created a block, an integration will return a ResolvedOutputSpec, with the actual
 * version/config used.
 */
interface OutputSpec {
    configuration?: OutputSpecConfig | null | undefined;
    rid: string;
    version?: ResourceVersion | null | undefined;
}
interface OutputSpecConfig_appConfigConfig {
    type: "appConfigConfig";
    appConfigConfig: AppConfigOutputSpecConfig;
}
interface OutputSpecConfig_authoringRepositoryConfig {
    type: "authoringRepositoryConfig";
    authoringRepositoryConfig: AuthoringRepositoryOutputSpecConfig;
}
interface OutputSpecConfig_automationConfig {
    type: "automationConfig";
    automationConfig: AutomationOutputSpecConfig;
}
interface OutputSpecConfig_cipherChannelConfig {
    type: "cipherChannelConfig";
    cipherChannelConfig: CipherChannelOutputSpecConfig;
}
interface OutputSpecConfig_cipherLicenseConfig {
    type: "cipherLicenseConfig";
    cipherLicenseConfig: CipherLicenseOutputSpecConfig;
}
interface OutputSpecConfig_contourConfig {
    type: "contourConfig";
    contourConfig: ContourOutputSpecConfig;
}
interface OutputSpecConfig_datasetConfig {
    type: "datasetConfig";
    datasetConfig: DatasetOutputSpecConfig;
}
interface OutputSpecConfig_eddiePipelineConfig {
    type: "eddiePipelineConfig";
    eddiePipelineConfig: EddiePipelineOutputSpecConfig;
}
interface OutputSpecConfig_mediaSetConfig {
    type: "mediaSetConfig";
    mediaSetConfig: MediaSetOutputSpecConfig;
}
interface OutputSpecConfig_modelConfig {
    type: "modelConfig";
    modelConfig: ModelOutputSpecConfig;
}
interface OutputSpecConfig_modelStudioConfig {
    type: "modelStudioConfig";
    modelStudioConfig: ModelStudioOutputSpecConfig;
}
interface OutputSpecConfig_computeModuleConfig {
    type: "computeModuleConfig";
    computeModuleConfig: ComputeModuleOutputSpecConfig;
}
interface OutputSpecConfig_objectViewConfig {
    type: "objectViewConfig";
    objectViewConfig: ObjectViewOutputSpecConfig;
}
interface OutputSpecConfig_objectTypeConfig {
    type: "objectTypeConfig";
    objectTypeConfig: ObjectTypeOutputSpecConfig;
}
/**
 * Some outputSpecs can have additional configurations, which are defined here. Any configuration type that does
 * not align with the outputSpec of a respective rid type will cause an error.
 */
type OutputSpecConfig = OutputSpecConfig_appConfigConfig | OutputSpecConfig_authoringRepositoryConfig | OutputSpecConfig_automationConfig | OutputSpecConfig_cipherChannelConfig | OutputSpecConfig_cipherLicenseConfig | OutputSpecConfig_contourConfig | OutputSpecConfig_datasetConfig | OutputSpecConfig_eddiePipelineConfig | OutputSpecConfig_mediaSetConfig | OutputSpecConfig_modelConfig | OutputSpecConfig_modelStudioConfig | OutputSpecConfig_computeModuleConfig | OutputSpecConfig_objectViewConfig | OutputSpecConfig_objectTypeConfig;
/**
 * Corresponds 1:1 with the member types of the OutputSpecConfig union.
 */
type OutputSpecConfigType = "APP_CONFIG" | "AUTHORING" | "AUTOMATION" | "CIPHER_CHANNEL" | "CIPHER_LICENSE" | "CONTOUR" | "DATASET" | "EDDIE_PIPELINE" | "MEDIA_SET" | "MODEL" | "MODEL_STUDIO" | "COMPUTE_MODULE" | "OBJECT_VIEW" | "OBJECT_TYPE";
interface OutputSpecError {
    blockType?: BlockType | null | undefined;
    error: CreateBlockVersionErrorUnion;
    severity: ErrorSeverity;
}
interface OutputSpecErrors_errors {
    type: "errors";
    errors: Array<OutputSpecError>;
}
interface OutputSpecErrors_insufficientPermissions {
    type: "insufficientPermissions";
    insufficientPermissions: Array<OutputSpecInsufficientPermissionsError>;
}
type OutputSpecErrors = OutputSpecErrors_errors | OutputSpecErrors_insufficientPermissions;
interface OutputSpecInsufficientPermissionsError {
    blockType?: BlockType | null | undefined;
    error: InsufficientPermissionsErrorUnion;
}
interface OutputSpecProvenance_explicit {
    type: "explicit";
    explicit: ExplicitProvenance;
}
interface OutputSpecProvenance_dependency {
    type: "dependency";
    dependency: DependencyProvenance;
}
interface OutputSpecProvenance_discovered {
    type: "discovered";
    discovered: DiscoveryProvenance;
}
interface OutputSpecProvenance_inferredFolderStructure {
    type: "inferredFolderStructure";
    inferredFolderStructure: Void;
}
/**
 * Order of union type mirrors the order these will be returned in the list.
 */
type OutputSpecProvenance = OutputSpecProvenance_explicit | OutputSpecProvenance_dependency | OutputSpecProvenance_discovered | OutputSpecProvenance_inferredFolderStructure;
interface OutputSpecResult {
    dependencies: Array<ResolvedOutputSpec>;
    dependenciesV2: Array<OutputSpec>;
    outputSpecs: Array<ResolvedOutputSpec>;
    result: GranularOutputSpecResult;
    specsAndProvenance: Array<ResolvedOutputSpecAndProvenance>;
}
/**
 * Constraint failure when installation is currently outside all maintenance windows
 */
interface OutsideMaintenanceWindowsConstraintFailure {
    nextMaintenanceWindow?: MaintenanceWindow | null | undefined;
}
/**
 * DEPRECATED alongside `OverlappingRecommendations`.
 *
 * One conflicting fulfillment contributing to an OverlappingRecommendations entry — the upstream member
 * providing the recommendation, the upstream output it maps to, and the downstream input shape the
 * recommendation fulfills.
 */
interface OverlappingRecommendation {
    downstreamInputShapeId: InputBlockSetShapeId;
    upstream: ProductGroupMemberRid;
    upstreamOutputShapeId: OutputBlockSetShapeId;
}
/**
 * DEPRECATED: replaced by `DuplicateOutputs.downstreamOverlappingRecommendations`. New validation
 * runs no longer emit this variant; historical snapshots may still contain it.
 *
 * Two or more recommendations on a downstream member fulfill the same input shape — each
 * from a different in-group upstream member, or the same upstream via mappings to distinct
 * outputs. Install-blocking: at install time this surfaces as the
 * OverlappingExternalRecommendations error. ERROR level.
 *
 * Only recommendations whose upstream is itself a member of the group are considered.
 * Stale mappings (output absent on the upstream's resolved version) are ignored, mirroring
 * install-time behaviour. Findings are rolled up by the downstream input's rollup parent.
 */
interface OverlappingRecommendations {
    downstream: ProductGroupMemberRid;
    overlaps: Record<InputBlockSetShapeId, Array<OverlappingRecommendation>>;
}
/**
 * All fields are optional. Only set fields will override metadata from the previous version. Unset versions will
 * propagate as normal.
 */
interface OverriddenMetadataFromStartingVersion {
    packagingSettings?: PackagingSettings | null | undefined;
}
interface OverriddenOutputSpecs {
    outputSpecs: Array<OutputSpec>;
}
/**
 * This shape is intended to represent a boolean config that a user can check if they want to allow their
 * Marketplace installation upgrade to override existing installed ontology entity API names. This would be
 * needed if any of the user's packaged entity API names have been modified, and the user wants the corresponding
 * installed entity API names to be updated to the modified packaged entity API name.
 *
 * This configuration should be enabled with caution, as it can break downstream applications that reference
 * ontology entities by their API names, such as functions and OSDK.
 *
 * A few constraints that Marketplace will enforce:
 * - This config cannot be used together with installation prefixes (enabling and configuring InstallPrefix), and
 * OMS will return a blocking validation error if both are set. This is because API name prefixing will break
 * downstream applications (e.g. OSDK, Functions) referencing entities by their API names that are packaged
 * together
 * - OMS will return blocking validation errors on API name upgrades if this config is not enabled, and
 * nonblocking validation errors if this config is enabled.
 * - Regardless of this configuration, installation will be blocked if the API name of an entity to be installed
 * is already used in the target ontology, until either is deduplicated to ensure uniqueness.
 */
interface OverrideOntologyEntityApiNamesShape {
    about: LocalizedTitleAndDescription;
}
interface OwnedBlockMetadata {
    creationTimestamp: CreationTimestamp;
    id: BlockId;
    marketplaceRid: MarketplaceRid;
}
interface OwnedPendingRecommendationSource {
    hasPlaceholderCompatibilityRange?: boolean | null | undefined;
    upstreamUpdateId: UpdatePendingBlockSetVersionSpecsRequestId;
    upstreamVersionId: BlockSetVersionId;
}
type PackageName = string;
type PackagingLogicVersion = "V1" | "V2";
/**
 * Settings defined by the user at packaging time that are tied to this particular version of the block set.
 * WARNING: Packaging settings do not currently get propagated between versions like other metadata. In order to
 * have these on start new version, this should be set in `OverriddenMetadataFromStartingVersion`. In the future,
 * this behaviour will change to propagate.
 */
interface PackagingSettings {
    inferredFolderStructure: InferredFolderStructureSettings;
}
/**
 * Number of items to return in a single page. May return more (usually defaults to minimum 10) or less (usually
 * defaults to maximum 100). Serves as a hint to the server, which can serve more/fewer results depending on what
 * ends up being more efficient.
 */
type PageSizeLimitHint = number;
interface ParameterAndAction {
    actionTypeIdentifier: ActionTypeIdentifier;
    parameterKey: ActionParameterRidOrId;
}
interface ParameterInputShape {
    about: LocalizedTitleAndDescription;
    id?: StableShapeIdentifier | null | undefined;
    parameterType: DataType;
}
interface ParameterPartialResolvedShape {
    about: LocalizedTitleAndDescription;
    currentValue: DataValue;
    id?: StableShapeIdentifier | null | undefined;
}
interface PartiallyDeletedInstallationRationale {
    blockSetInstallationRid: BlockSetInstallationRid;
}
/**
 * Same as `ResolvedOutputSpec`, but only the configuration has been resolved, not the version.
 */
interface PartiallyResolvedOutputSpec {
    configuration: ResolvedOutputSpecConfig;
    rid: string;
    version?: ResourceVersion | null | undefined;
}
interface PathPolicy_any {
    type: "any";
    any: Void;
}
interface PathPolicy_pathRequired {
    type: "pathRequired";
    pathRequired: Void;
}
interface PathPolicy_pathNotSupported {
    type: "pathNotSupported";
    pathNotSupported: Void;
}
type PathPolicy = PathPolicy_any | PathPolicy_pathRequired | PathPolicy_pathNotSupported;
interface PdfFormat {
}
interface PeerProducerProfileIdentifier {
    peerProducerProfileRid: PeerProducerProfileRid;
    peerProducerUri: ProducerUri;
    peerProfileRid: PeerProfileRid;
}
type PeerProducerProfileRid = string;
interface PeerProducerProfileShape {
    about: LocalizedTitleAndDescription;
}
/**
 * Creates a peering orchestration block for the given peer profile rid
 */
interface PeerProfileCreateBlockRequest {
    peerProfileRid: string;
}
interface PeerProfileIdentifier {
    rid: PeerProfileRid;
}
/**
 * This is essentially a copy of the unresolved shape. This is will allow us to build the unresolved
 * shape off of the identifier. We are not expecting to build the resolved shape off of the identifier
 * since this will be unknown on the packaging stack.
 */
interface PeerProfileRemoteStrategyIdentifier {
    about: LocalizedTitleAndDescription;
    allowedRemoteStrategyTypes: Array<PeerProfileRemoteStrategyType>;
    stableIdentifier: StableShapeIdentifier;
}
interface PeerProfileRemoteStrategyMismatch {
    actual: PeerProfileRemoteStrategyType;
    expected: Array<PeerProfileRemoteStrategyType>;
}
interface PeerProfileRemoteStrategyShape {
    about: LocalizedTitleAndDescription;
    allowedRemoteStrategyTypes: Array<PeerProfileRemoteStrategyType>;
    stableIdentifier: StableShapeIdentifier;
}
type PeerProfileRemoteStrategyType = "SPECIFIC_REMOTE" | "MESH_ID" | "MESH_NODE_LABEL";
type PeerProfileRid = string;
interface PeerProfileShape {
    about: LocalizedTitleAndDescription;
}
type PendingBlockSetInputShapes = Record<InputBlockSetShapeId, PendingInputBlockSetMappingInfo>;
/**
 * Output block set shape IDs uniquely map to a set of backing output shapes that share a single merge key.
 */
type PendingBlockSetOutputShapes = Record<OutputBlockSetShapeId, PendingOutputBlockSetMappingInfo>;
/**
 * Metadata for a pending block set version before it has been finalised at a specific semver.
 */
interface PendingBlockSetVersionMetadata {
    about: LocalizedTitleAndDescription;
    createdByUser?: MultipassUserId | null | undefined;
    creationTimestamp: CreationTimestamp;
    defaultInstallationSettings?: DefaultInstallationSettings | null | undefined;
    draftGroupRid?: DraftGroupRid | null | undefined;
    id: BlockSetId;
    isHotfix?: boolean | null | undefined;
    lastUpdatedTimestamp: LastUpdatedTimestamp;
    marketplaceRid: MarketplaceRid;
    packagingSettings?: PackagingSettings | null | undefined;
    startingVersionId?: BlockSetVersionId | null | undefined;
    startingVersionSemver?: SemverVersion | null | undefined;
    tagsV2: BlockSetCategorizedTags;
    typedTags: Array<TagRid>;
    version?: SemverVersion | null | undefined;
    versionId: BlockSetVersionId;
    versionIncrement?: VersionIncrement | null | undefined;
}
interface PendingBuildInstallPendingStatus {
}
/**
 * `StoredInputBlockSetMappingInfo` but for pending block sets. The only difference is that this data structure
 * supports input shapes that can not be merged.
 */
interface PendingInputBlockSetMappingInfo {
    isOptional: boolean;
    metadata?: InputBlockSetShapeMetadata | null | undefined;
    shapes: Array<BlockSetInputShapeWithBackingShapes>;
}
/**
 * `StoredOutputBlockSetMappingInfo` but for pending block sets. The only difference is that this data structure
 * supports having multiple block outputs mapped to a single block set output.
 */
interface PendingOutputBlockSetMappingInfo {
    shapes: Array<BlockSetOutputShapeWithBackingShape>;
}
interface PendingRecommendationStatus_processing {
    type: "processing";
    processing: Void;
}
interface PendingRecommendationStatus_complete {
    type: "complete";
    complete: Array<ExternalRecommendationV2>;
}
type PendingRecommendationStatus = PendingRecommendationStatus_processing | PendingRecommendationStatus_complete;
interface PermanentlyDeleteUninstallOptions {
    forceDelete?: boolean | null | undefined;
}
interface PinnedMediaSetView {
    endExclusiveTimestamp: number;
    mediaSetViewRid: string;
}
interface PinnedVersionPolicy {
    blockSetVersionId: BlockSetVersionId;
}
interface PlaceholdersLocation {
    compassFolder?: CompassFolderRid | null | undefined;
}
interface PlainTextTypeUnsupported {
    unsupportedPlainTextType: string;
}
interface PlyFormat {
}
interface PngFormat {
}
/**
 * Port configuration used for external networking
 */
interface PortConfig {
    name: string;
    port: number;
}
/**
 * If a dataset build was successfully submitted at the end of installation, we provide the build details here.
 * This does not provide any guarantees that the build has finished running.
 */
interface PostInstallationBuildMetadata {
    buildRid: BuildRid;
    jobRidsByShapeIds: Record<BlockShapeId, JobRid>;
}
interface PostInstallationJobTask_buildMetadata {
    type: "buildMetadata";
    buildMetadata: PostInstallationBuildMetadata;
}
type PostInstallationJobTask = PostInstallationJobTask_buildMetadata;
/**
 * An upstream member whose outputs match a downstream input's merge keys.
 */
interface PotentialInputProvider {
    matchingOutputShapeIds: Array<OutputBlockSetShapeId>;
    upstream: ProductGroupMemberRid;
}
interface PptxFormat {
}
/**
 * RESOURCE_PREALLOCATION_REQUIRED requires the resource has been preallocated already
 * by the block that owns it, resulting in the resource being available during preallocation
 * as a resolved input shape.
 *
 * Any input shape transitively referenced by a shape with this requirement is also treated
 * as requiring preallocation, so that shape dereferencing always has access to the inputs
 * it depends on.
 */
type PreallocateAccessRequirementType = "RESOURCE_PREALLOCATION_REQUIRED";
interface PreallocatingInstallPendingStatus {
}
/**
 * Deprecated: Use StableFunctionsApiStabilityConfiguration instead.
 *
 * This configuration indicates that on installation or upgrade of a Marketplace package, the version of a
 * function that is chosen during block pre-allocation is determined by just using the source function's
 * version.
 *
 * For example, if a function at version "1.2.3" is packaged, pre-allocation will return version "1.2.3".
 *
 * If there is a version conflict (e.g., from releases after unlocking an installation, reconfiguring an
 * installation, etc.), then pre-allocation will fail.
 *
 * This is the recommended configuration to ensure stability of function versions.
 */
interface PreserveFunctionVersionsConfiguration {
}
/**
 * Whether or not resolved presets will be enforced at installation time.
 * - SUGGESTED: The presets will be suggested to the installing user, but they can chose to override the value.
 * - MANDATORY: The presets will be enforced. An install request trying to change the presets value will fail.
 */
type PresetEnforcement = "SUGGESTED" | "MANDATORY";
interface PresetFromSource {
    resolver: InputShapeResolver;
}
/**
 * The preset resolution for the shape failed, and was required to determine if the provided input shape
 * satisfies mandatory presets for the shape.
 */
interface PresetResolutionFailedError {
    resolutionErrors: Array<ResolvedShapeResolutionFailure>;
}
interface PresetResolvedShapeOverrides {
    defaultIndex?: number | null | undefined;
    resolvedShapes: Array<ResolvedBlockSetInputShape>;
    resolvers: Array<InputShapeResolver>;
}
interface PresetValue_fromSource {
    type: "fromSource";
    fromSource: PresetFromSource;
}
interface PresetValue_resolvedShapeOverrides {
    type: "resolvedShapeOverrides";
    resolvedShapeOverrides: PresetResolvedShapeOverrides;
}
type PresetValue = PresetValue_fromSource | PresetValue_resolvedShapeOverrides;
interface PreviewCleanupUnusedShapesResponse {
    outputShapePreviews: Array<OutputShapeCleanupPreview>;
}
interface PreviewDiscoveryRequest {
    discoverySpecs: Array<DiscoverySpec>;
    settings?: DiscoverySettings | null | undefined;
}
interface PreviewDiscoveryResponse {
    results: Array<PreviewDiscoveryResult>;
}
/**
 * The result of discovery specs. Stored and re-used for caching in future iterations.
 */
interface PreviewDiscoveryResult {
    ignoredSpecs: Array<OutputSpec>;
    includedSpecs: Array<OutputSpec>;
    rootDiscoverySpec: DiscoverySpec;
}
interface PreviewUninstallResponse {
    outputShapePreviews: Record<OutputBlockSetShapeId, OutputShapeUninstallPreview>;
}
interface PrimitiveBaseType_boolean {
    type: "boolean";
    boolean: Void;
}
interface PrimitiveBaseType_binary {
    type: "binary";
    binary: Void;
}
interface PrimitiveBaseType_byte {
    type: "byte";
    byte: Void;
}
interface PrimitiveBaseType_date {
    type: "date";
    date: Void;
}
interface PrimitiveBaseType_decimal {
    type: "decimal";
    decimal: Void;
}
interface PrimitiveBaseType_double {
    type: "double";
    double: Void;
}
interface PrimitiveBaseType_float {
    type: "float";
    float: Void;
}
interface PrimitiveBaseType_integer {
    type: "integer";
    integer: Void;
}
interface PrimitiveBaseType_long {
    type: "long";
    long: Void;
}
interface PrimitiveBaseType_map {
    type: "map";
    map: Void;
}
interface PrimitiveBaseType_optional {
    type: "optional";
    optional: Void;
}
interface PrimitiveBaseType_short {
    type: "short";
    short: Void;
}
interface PrimitiveBaseType_string {
    type: "string";
    string: Void;
}
interface PrimitiveBaseType_struct {
    type: "struct";
    struct: Void;
}
interface PrimitiveBaseType_structV2 {
    type: "structV2";
    structV2: Void;
}
interface PrimitiveBaseType_timestamp {
    type: "timestamp";
    timestamp: Void;
}
type PrimitiveBaseType = PrimitiveBaseType_boolean | PrimitiveBaseType_binary | PrimitiveBaseType_byte | PrimitiveBaseType_date | PrimitiveBaseType_decimal | PrimitiveBaseType_double | PrimitiveBaseType_float | PrimitiveBaseType_integer | PrimitiveBaseType_long | PrimitiveBaseType_map | PrimitiveBaseType_optional | PrimitiveBaseType_short | PrimitiveBaseType_string | PrimitiveBaseType_struct | PrimitiveBaseType_structV2 | PrimitiveBaseType_timestamp;
interface PrimitiveObjectPropertyType_stringType {
    type: "stringType";
    stringType: Void;
}
interface PrimitiveObjectPropertyType_booleanType {
    type: "booleanType";
    booleanType: Void;
}
interface PrimitiveObjectPropertyType_byteType {
    type: "byteType";
    byteType: Void;
}
interface PrimitiveObjectPropertyType_dateType {
    type: "dateType";
    dateType: Void;
}
interface PrimitiveObjectPropertyType_decimalType {
    type: "decimalType";
    decimalType: Void;
}
interface PrimitiveObjectPropertyType_doubleType {
    type: "doubleType";
    doubleType: Void;
}
interface PrimitiveObjectPropertyType_floatType {
    type: "floatType";
    floatType: Void;
}
interface PrimitiveObjectPropertyType_geohashType {
    type: "geohashType";
    geohashType: Void;
}
interface PrimitiveObjectPropertyType_geoshapeType {
    type: "geoshapeType";
    geoshapeType: Void;
}
interface PrimitiveObjectPropertyType_geotimeSeriesReferenceType {
    type: "geotimeSeriesReferenceType";
    geotimeSeriesReferenceType: Void;
}
interface PrimitiveObjectPropertyType_integerType {
    type: "integerType";
    integerType: Void;
}
interface PrimitiveObjectPropertyType_longType {
    type: "longType";
    longType: Void;
}
interface PrimitiveObjectPropertyType_shortType {
    type: "shortType";
    shortType: Void;
}
interface PrimitiveObjectPropertyType_timeDependentType {
    type: "timeDependentType";
    timeDependentType: Void;
}
interface PrimitiveObjectPropertyType_timestampType {
    type: "timestampType";
    timestampType: Void;
}
interface PrimitiveObjectPropertyType_attachmentType {
    type: "attachmentType";
    attachmentType: Void;
}
interface PrimitiveObjectPropertyType_markingType {
    type: "markingType";
    markingType: Void;
}
interface PrimitiveObjectPropertyType_mediaReferenceType {
    type: "mediaReferenceType";
    mediaReferenceType: Void;
}
interface PrimitiveObjectPropertyType_vectorType {
    type: "vectorType";
    vectorType: VectorPropertyType;
}
interface PrimitiveObjectPropertyType_cipherTextType {
    type: "cipherTextType";
    cipherTextType: CipherTextPropertyType;
}
interface PrimitiveObjectPropertyType_structType {
    type: "structType";
    structType: StructPropertyType;
}
/**
 * Represents the primitive types for Ontology properties.
 */
type PrimitiveObjectPropertyType = PrimitiveObjectPropertyType_stringType | PrimitiveObjectPropertyType_booleanType | PrimitiveObjectPropertyType_byteType | PrimitiveObjectPropertyType_dateType | PrimitiveObjectPropertyType_decimalType | PrimitiveObjectPropertyType_doubleType | PrimitiveObjectPropertyType_floatType | PrimitiveObjectPropertyType_geohashType | PrimitiveObjectPropertyType_geoshapeType | PrimitiveObjectPropertyType_geotimeSeriesReferenceType | PrimitiveObjectPropertyType_integerType | PrimitiveObjectPropertyType_longType | PrimitiveObjectPropertyType_shortType | PrimitiveObjectPropertyType_timeDependentType | PrimitiveObjectPropertyType_timestampType | PrimitiveObjectPropertyType_attachmentType | PrimitiveObjectPropertyType_markingType | PrimitiveObjectPropertyType_mediaReferenceType | PrimitiveObjectPropertyType_vectorType | PrimitiveObjectPropertyType_cipherTextType | PrimitiveObjectPropertyType_structType;
interface Principal {
    id: PrincipalId;
    type: PrincipalType;
}
type PrincipalId = string;
type PrincipalType = "EVERYONE" | "GROUP" | "USER";
/**
 * Automation is currently planning a potential upgrade, and has nothing to report yet
 */
interface ProcessingStatus {
}
interface ProcessingStatusV3 {
}
/**
 * Each peer producer service can support one or many producer URIs. These are static, low cardinality
 * identifiers for the type of data the producer supports. For example, foundry/peering supports
 * both funnel and object-set peering producers. This URI makes sure producer profile
 * inputs/outputs line up on this dimension.
 */
type ProducerUri = string;
type ProductDisplayVersion = string;
/**
 * A product group contains a set of Marketplace products (block sets) that are co-deployed,
 * with configurable version policies and validation checks.
 */
interface ProductGroup {
    currentDefinition: VersionedProductGroupDefinition;
    productGroupRid: ProductGroupRid;
}
/**
 * Unique identifier for a given member of a product group.
 */
type ProductGroupMemberRid = string;
interface ProductGroupMemberSpec_installation {
    type: "installation";
    installation: InstallationProductGroupMember;
}
interface ProductGroupMemberSpec_blockSet {
    type: "blockSet";
    blockSet: BlockSetProductGroupMember;
}
/**
 * The source of a product group member. Determines how the block set is referenced.
 */
type ProductGroupMemberSpec = ProductGroupMemberSpec_installation | ProductGroupMemberSpec_blockSet;
/**
 * Unique identifier for a product group. Used as a Compass resource RID.
 */
type ProductGroupRid = string;
/**
 * An instance of a product group. The snapshot contains the set of resolved product versions at the time
 * in which the snapshot was computed along with any validation findings based on the product group's
 * definition.
 */
interface ProductGroupSnapshot {
    creationTimestamp: CreationTimestamp;
    details?: ProductGroupSnapshotDetails | null | undefined;
    productGroupRid: ProductGroupRid;
    productGroupVersionRid: ProductGroupVersionRid;
    snapshotRid: ProductGroupSnapshotRid;
}
/**
 * Additional details of a product group snapshot, gated by the requestor's access to the resolved members.
 */
interface ProductGroupSnapshotDetails {
    snapshotMemberVersions: Array<SnapshotMemberVersion>;
    trigger: ProductGroupSnapshotTrigger;
    validationFindings: Array<ProductGroupValidationFinding>;
    validationStatus: ProductGroupValidationStatus;
}
/**
 * Unique identifier for a product group snapshot.
 */
type ProductGroupSnapshotRid = string;
interface ProductGroupSnapshotTrigger_manual {
    type: "manual";
    manual: ManualProductGroupSnapshotTrigger;
}
/**
 * The reason a snapshot was triggered.
 */
type ProductGroupSnapshotTrigger = ProductGroupSnapshotTrigger_manual;
/**
 * A single validation finding for a product group.
 */
interface ProductGroupValidationFinding {
    detail: ProductGroupValidationFindingDetail;
    findingLevel: ProductGroupValidationFindingLevel;
    findingRid: ProductGroupValidationFindingRid;
}
interface ProductGroupValidationFindingDetail_duplicateOutputs {
    type: "duplicateOutputs";
    duplicateOutputs: DuplicateOutputs;
}
interface ProductGroupValidationFindingDetail_incompatibleExternalRecommendationVersionRange {
    type: "incompatibleExternalRecommendationVersionRange";
    incompatibleExternalRecommendationVersionRange: IncompatibleExternalRecommendationVersionRange;
}
interface ProductGroupValidationFindingDetail_memberDependencyCycle {
    type: "memberDependencyCycle";
    memberDependencyCycle: MemberDependencyCycle;
}
interface ProductGroupValidationFindingDetail_missingRecommendation {
    type: "missingRecommendation";
    missingRecommendation: MissingRecommendation;
}
interface ProductGroupValidationFindingDetail_overlappingRecommendations {
    type: "overlappingRecommendations";
    overlappingRecommendations: OverlappingRecommendations;
}
interface ProductGroupValidationFindingDetail_unfulfilledInput {
    type: "unfulfilledInput";
    unfulfilledInput: UnfulfilledInput;
}
/**
 * Detailed information about a specific validation finding.
 */
type ProductGroupValidationFindingDetail = ProductGroupValidationFindingDetail_duplicateOutputs | ProductGroupValidationFindingDetail_incompatibleExternalRecommendationVersionRange | ProductGroupValidationFindingDetail_memberDependencyCycle | ProductGroupValidationFindingDetail_missingRecommendation | ProductGroupValidationFindingDetail_overlappingRecommendations | ProductGroupValidationFindingDetail_unfulfilledInput;
/**
 * The severity level of a validation finding.
 */
type ProductGroupValidationFindingLevel = "INFO" | "WARN" | "ERROR";
/**
 * Identifier for a single product group validation finding. Generated freshly each time
 * a validation runs, so it is stable within the findings produced by one run (whether
 * surfaced through validateProducts or persisted into a snapshot) but not across runs.
 */
type ProductGroupValidationFindingRid = string;
/**
 * Validation settings for a product group.
 */
interface ProductGroupValidationSettings {
}
interface ProductGroupValidationStatus_valid {
    type: "valid";
    valid: ValidProductGroupValidationStatus;
}
interface ProductGroupValidationStatus_warn {
    type: "warn";
    warn: WarnProductGroupValidationStatus;
}
interface ProductGroupValidationStatus_error {
    type: "error";
    error: ErrorProductGroupValidationStatus;
}
/**
 * The overall validation status, derived from the highest severity finding.
 * VALID indicates no findings or only INFO-level findings. WARN and ERROR
 * correspond to the highest finding level present.
 */
type ProductGroupValidationStatus = ProductGroupValidationStatus_valid | ProductGroupValidationStatus_warn | ProductGroupValidationStatus_error;
/**
 * Unique identifier for a particular version of a product group.
 */
type ProductGroupVersionRid = string;
type ProductId = string;
/**
 * The installation mode of the product is a suggestion for properties of the installations of this product.
 *
 * PRODUCTION products are suggested to:
 * - be installed into a locked-down project and the resources are not editable
 * - have automatic upgrades enabled
 *
 * BOOTSTRAPPER products suggested to
 * - be installed into a project that is editable
 * - have automatic upgrades disabled
 *
 * SINGLETON products are suggested to:
 * - behave in the same way as production mode
 * - enforce source api names & block upgrades if api names conflict or another install already exists in the namespace
 *
 * See more documentation under `setBlockSetInstallationImmutability` in the marketplace-api.
 *
 * Defaults to PRODUCTION.
 */
type ProductInstallationMode = "PRODUCTION" | "BOOTSTRAPPER" | "SINGLETON";
/**
 * Product types allow us to make recommendations about what type entities should be included in the product.
 * e.g. An 'ONTOLOGY' product is recommended to contain object types, link types and action types.
 *
 * These recommendations are not enforced.
 *
 * Defaults to NONE.
 */
type ProductType = "NONE" | "DATA_CONNNECTION" | "MODELING" | "ONTOLOGY" | "PIPELINE" | "USE_CASE";
type ProductVersionId = string;
/**
 * First-class metadata for products (a wrapper around block sets), usually extracted from the block set tags.
 */
interface ProductVersionMetadata {
    about: LocalizedTitleAndDescription;
    activeRecalls: Record<RecallId, RecallVersionsAnnouncement>;
    backingBlockSet: BlockSetVersionReference;
    createdAt: CreationTimestamp;
    displayVersion: ProductDisplayVersion;
    installationMode: ProductInstallationMode;
    productId: ProductId;
    productVersionId: ProductVersionId;
    releaseChannels: Array<ReleaseChannel>;
    status: ProductVersionStatus;
    type: ProductType;
}
/**
 * A version of a products can be deprecated.
 *
 * Defaults to NONE (which implies the product is safe to install).
 */
type ProductVersionStatus = "NONE" | "DEPRECATED";
/**
 * Profile must belong to the specified family
 */
interface ProfileFamilyConstraint {
    familyName: SparkProfileFamilyName;
}
type ProjectContext = string;
/**
 * Capabilities for changing project mutability.
 */
interface ProjectMutabilityCapabilities {
    canSetProjectMutability: SetProjectMutabilityAllowance;
}
interface PropertyAndObject {
    objectTypeIdentifier: ObjectTypeIdentifier;
    propertyKey: PropertyTypeRidOrId;
    requireSharedPropertyType?: boolean | null | undefined;
}
interface PropertyIdentifier_propertyAndObject {
    type: "propertyAndObject";
    propertyAndObject: PropertyAndObject;
}
type PropertyIdentifier = PropertyIdentifier_propertyAndObject;
interface PropertyInputShape {
    about: LocalizedTitleAndDescription;
    inlineActionType?: ActionTypeReference | null | undefined;
    objectType: ObjectTypeReference;
    sharedPropertyType?: SharedPropertyTypeReference | null | undefined;
    type: AllowedObjectPropertyType;
}
interface PropertyOutputShape {
    about: LocalizedTitleAndDescription;
    dataConstraints?: DataConstraints | null | undefined;
    inlineActionType?: ActionTypeReference | null | undefined;
    objectType: ObjectTypeReference;
    sharedPropertyType?: SharedPropertyTypeReference | null | undefined;
    type: ObjectPropertyType;
}
type PropertyTypeId = string;
interface PropertyTypeMismatch {
    actual: ObjectPropertyType;
    expected: ObjectPropertyType;
}
interface PropertyTypeNotFound {
    objectTypeId?: ObjectTypeId | null | undefined;
    objectTypeRid?: ObjectTypeRid | null | undefined;
    propertyTypeId?: PropertyTypeId | null | undefined;
    propertyTypeRid?: PropertyTypeRid | null | undefined;
}
type PropertyTypeRid = string;
interface PropertyTypeRidOrId_rid {
    type: "rid";
    rid: PropertyTypeRid;
}
interface PropertyTypeRidOrId_id {
    type: "id";
    id: PropertyTypeId;
}
type PropertyTypeRidOrId = PropertyTypeRidOrId_rid | PropertyTypeRidOrId_id;
/**
 * An unknown type of PropertyType definition was encountered. This indicates we might have run into a new
 * kind of PropertyType that isn't yet supported in Marketplace.
 */
interface PropertyTypeUnknown {
    unknownType: string;
}
/**
 * The proposed location to install a block into. Additional targets might be added to this object in the future.
 * Used by `MarketplaceBlockInstallerService`. This is different from `InstallLocation`, which is used by the
 * `BlockInstallationService.installBlocksV2`, and from BlockInstallLocation, which is used by
 * MarketplaceBlockInstallerService in the preallocate and reconcile steps. This is instead used by
 * MarketplaceBlockInstallerService.validateInstallBlockRequest, which checks if the block can be installed. The
 * main difference is that the compass install location is optional here, as  the project is created during
 * installation, and we do not want to create a new project during the validation step.
 */
interface ProposedBlockInstallLocation {
    compass?: CompassInstallLocation | null | undefined;
    compassV2: ProposedCompassInstallLocation;
    ontology?: OntologyInstallLocation | null | undefined;
}
/**
 * The Compass location to install a block into.
 */
interface ProposedCompassInstallLocation {
    compassFolderRid?: CompassFolderRid | null | undefined;
    namespaceRid: NamespaceRid;
    newProjectOrExistingFolder: NewProjectOrExistingFolder;
}
interface PutCategoryRequest {
    name: LocalizedName;
    rid?: CategoryRid | null | undefined;
    tags: Array<PutTagRequest>;
}
/**
 * See docs on `StoreMetadata`.
 */
interface PutMarketplaceMetadataRequest {
    categories: Array<PutCategoryRequest>;
    latestKnownVersion: MarketplaceMetadataVersion;
    linkedStores?: Array<MarketplaceRid> | null | undefined;
    requireApprovals?: boolean | null | undefined;
}
interface PutTagRequest {
    name: LocalizedName;
    rid?: TagRid | null | undefined;
}
interface PypiLocator {
    fileName: string;
    md5Digest?: string | null | undefined;
    project: string;
    requiresPython?: string | null | undefined;
    sha256Digest?: string | null | undefined;
    url: string;
}
interface QuiverCreateBlockRequest {
    rid: string;
    version?: number | null | undefined;
}
/**
 * Quiver dashboard entity identifier for generating quiver shapes
 */
interface QuiverDashboardIdentifier {
    rid: string;
    version?: number | null | undefined;
}
/**
 * Quiver dashboard shape
 */
interface QuiverDashboardShape {
    about: LocalizedTitleAndDescription;
}
/**
 * If included in a Cipher License, the user has the ability to encrypt or decrypt (depending on the RequestType)
 * up to the limit specified.
 */
interface RateLimitedRequestPermit {
    requestType: RequestType;
}
/**
 * Unique identifier for a recall.
 */
type RecallId = string;
/**
 * A recall announcement made by the packager to recall a blockset version. This announcement is used by
 * Marketplace to to block target versions from being installed, and triggering roll-offs for installers based
 * on the specified roll-off strategy.
 */
interface RecallVersionsAnnouncement {
    createdAt?: string | null | undefined;
    id: RecallId;
    message: string;
    strategy: RollOffStrategy;
    targetVersions: Array<BlockSetVersionId>;
}
interface RecommendationBlockReference {
    block: VersionRangeBlockReference;
    shapeId: BlockShapeId;
}
/**
 * DEPRECATED: Replaced by block set shapes internal recommendations.
 */
interface RecommendationBlockSetReference {
    block: VersionRangeBlockSetReference;
    shapeId: BlockShapeId;
}
interface RecommendationEntryBody_simple {
    type: "simple";
    simple: SimpleRecommendation;
}
interface RecommendationEntryBody_actionType {
    type: "actionType";
    actionType: ActionTypeRecommendation;
}
type RecommendationEntryBody = RecommendationEntryBody_simple | RecommendationEntryBody_actionType;
/**
 * Two layers of granularity are provided to specify the access requirements for an input shape: either
 * RESOURCE_EXISTENCE_REQUIRED, which requires the resource has been created or SCHEMA_UPDATE_REQUIRED, which
 * will guarantee that the input must be built with the latest schema before reconciliation. Schema existence is
 * only relevant for dataset types.
 *
 * If the output is permissioned based on a given input, RESOURCE_EXISTENCE_REQUIRED should always be specified
 * so that the upstream input is guaranteed to exist in Gatekeeper.
 *
 * Specifying SCHEMA_UPDATE_REQUIRED will also guarantee RESOURCE_EXISTENCE_REQUIRED is fulfilled.
 * If SCHEMA_UPDATE_REQUIRED is specified, the shape type and block type must be allowlisted in
 * `SchemaUpdateReconcileAccessValidator`, else we will throw on block creation.
 */
type ReconcileAccessRequirementType = "RESOURCE_EXISTENCE_REQUIRED" | "SCHEMA_UPDATE_REQUIRED";
interface ReconcilingInstallPendingStatus {
}
interface RefreshSpecsConfig_refreshAll {
    type: "refreshAll";
    refreshAll: Void;
}
interface RefreshSpecsConfig_refreshDiscovery {
    type: "refreshDiscovery";
    refreshDiscovery: Void;
}
interface RefreshSpecsConfig_refreshMaterialization {
    type: "refreshMaterialization";
    refreshMaterialization: Void;
}
interface RefreshSpecsConfig_refreshNone {
    type: "refreshNone";
    refreshNone: Void;
}
interface RefreshSpecsConfig_refreshSubset {
    type: "refreshSubset";
    refreshSubset: Array<OutputSpec>;
}
/**
 * Refreshing specs affects both discovery specs and output specs:
 * - When output specs are refreshed, they are re-resolved (e.g., the latest version is picked up) and the
 * materialized blocks and shapes are re-computed. This always occurs if there is no previous result for the
 * specs.
 * - When discovery specs are refreshed, the root RID is re-synced (i.e., new resources in the folder are
 * discovered, and removed resources are removed).
 */
type RefreshSpecsConfig = RefreshSpecsConfig_refreshAll | RefreshSpecsConfig_refreshDiscovery | RefreshSpecsConfig_refreshMaterialization | RefreshSpecsConfig_refreshNone | RefreshSpecsConfig_refreshSubset;
/**
 * Request to register a versionless installation. Creates installation metadata without running a job
 * and without specifying a version. The installation can later be upgraded via `installBlockSets` with
 * `modifyExistingInstallations`.
 */
interface RegisterInstallationRequest {
    blockSetId: BlockSetId;
    installationSuffix?: string | null | undefined;
    installLocation: TargetRegistrationLocation;
    marketplaceRid: MarketplaceRid;
    targetVersionHint?: BlockSetVersionId | null | undefined;
}
interface RegisterInstallationResponse {
    installationRid: BlockSetInstallationRid;
}
/**
 * Includes raw public key string to be registered, and maven coordinates that the key is able to verify.
 */
interface RegisterKeyRequest {
    mavenCoordinates: MavenCoordinates;
    publicKey: SigningPublicKey;
}
interface RegisterKeyResponse {
}
type ReleaseChannel = string;
/**
 * Resolves to the latest block set version that belongs to any of the specified release channels.
 */
interface ReleaseChannelVersionPolicy {
    releaseChannels: Array<ReleaseChannel>;
}
type ReleaseRid = string;
interface RemoveFromDraftGroupRequest {
    versionIds: Array<BlockSetVersionId>;
}
/**
 * Reference a patched repodata in a conda layout. It allows to ship patched environments that may not be solvable in destination stacks
 */
interface RepoDataLocator {
    platform: string;
}
type RepositorySourceCodePackagingType = "OMIT_SOURCE_CODE" | "SHALLOW_CLONE" | "DEEP_CLONE";
type RequestType = "ENCRYPT" | "DECRYPT";
/**
 * A parameter shape specified in the block metadata is missing from the ResolvedActionType.
 */
interface RequiredActionParameterTypeShapeMissing {
}
interface ResolvedActionTypeParameterShape {
    actionTypeRid: ActionTypeRid;
    actionTypeVersion: ActionTypeVersion;
    ontologyRid: OntologyRid;
    parameterId: ActionParameterId;
    parameterRid: ActionParameterRid;
}
/**
 * Shape Id that was resolved for the ActionType does not match the shape id expected.
 */
interface ResolvedActionTypeReferenceMismatch {
    actual: ActionTypeReference;
    expected: ActionTypeReference;
}
interface ResolvedActionTypeShape {
    apiName?: ActionTypeApiName | null | undefined;
    ontologyRid: OntologyRid;
    parameters: Record<ActionParameterShapeId, ActionTypeParameterIdentifiers>;
    rid: ActionTypeRid;
    version: ActionTypeVersion;
}
interface ResolvedAipAgentShape {
    agentRid: AipAgentRid;
    agentVersion: AipAgentVersion;
}
/**
 * See docs of `AllowSchemaMigrationsShape` for details.
 */
interface ResolvedAllowOntologySchemaMigrationsShape {
    allowCastMigrations: boolean;
    allowDropMigrations: boolean;
    allowRenameDatasourceMigrations?: boolean | null | undefined;
    allowRenamePropertyMigrations?: boolean | null | undefined;
}
/**
 * In order to identify a library, we need both the rid of the Artifacts repository it lives in, as well as the
 * locator of the library within this repository (e.g in the case of a Python library under the Conda layout,
 * we need the Conda locator to identify the library within the repository). For more, see
 * https://rtfm.palantir.build/docs/artifacts/develop/overview.html#layouts
 */
interface ResolvedAuthoringLibraryShape {
    locator: AuthoringLibraryLocator;
    repositoryRid: ArtifactsRepositoryRid;
}
interface ResolvedAutomationShape {
    rid: string;
}
type ResolvedBlockSetInputGroup = ResolvedInputGroup;
interface ResolvedBlockSetInputOrRef_resolvedInputShape {
    type: "resolvedInputShape";
    resolvedInputShape: ResolvedBlockSetInputShape;
}
interface ResolvedBlockSetInputOrRef_referenceOtherOutput {
    type: "referenceOtherOutput";
    referenceOtherOutput: BlockSetOutputReference;
}
interface ResolvedBlockSetInputOrRef_referenceExistingOutputInStore {
    type: "referenceExistingOutputInStore";
    referenceExistingOutputInStore: BlockSetInstallationOutputReference;
}
interface ResolvedBlockSetInputOrRef_fromDefault {
    type: "fromDefault";
    fromDefault: ResolvedBlockSetInputShape;
}
interface ResolvedBlockSetInputOrRef_automapped {
    type: "automapped";
    automapped: AutomappedInput;
}
type ResolvedBlockSetInputOrRef = ResolvedBlockSetInputOrRef_resolvedInputShape | ResolvedBlockSetInputOrRef_referenceOtherOutput | ResolvedBlockSetInputOrRef_referenceExistingOutputInStore | ResolvedBlockSetInputOrRef_fromDefault | ResolvedBlockSetInputOrRef_automapped;
type ResolvedBlockSetInputShape = ResolvedInputShape;
type ResolvedBlockSetOutputShape = ResolvedOutputShape;
interface ResolvedCipherLicenseShape {
    rid: CipherLicenseRid;
}
interface ResolvedCodeWorkspaceInputShape {
    containerRid: ContainerRid;
    containerVersionId: ContainerVersionId;
}
interface ResolvedCodeWorkspaceLicenseInputShape {
    licenseRid: string;
}
interface ResolvedCodeWorkspaceOutputShape {
    containerRid: ContainerRid;
    containerVersionId: ContainerVersionId;
}
/**
 * Contour Analysis resolved shape. Uniquely identifies an analysis resource by its RID.
 * The detailed analysis export data (refs, nodes, board states) is stored in block data
 * in Artifacts at packaging time, not in the Marketplace API.
 */
interface ResolvedContourAnalysisShape {
    rid: ContourAnalysisRid;
}
/**
 * Resolved Contour Ref shape containing both the analysis RID (for security/parent context)
 * and the target ref RID (the resolved value).
 */
interface ResolvedContourRefShape {
    analysisRid: ContourAnalysisRid;
    refRid: ContourRefRid;
}
interface ResolvedDatasourceColumnShape {
    datasource: DatasourceLocator;
    name: string;
}
interface ResolvedDatasourceShape {
    datasourceLocator: DatasourceLocator;
}
/**
 * An instance of a parameter. Must match the type requested in EddieEdgeParameterInputShape.
 */
interface ResolvedEddieEdgeParameterShape {
    instantiation: ResolvedEddieParameter;
    stableId?: EddieEdgeStableParameterId | null | undefined;
}
interface ResolvedEddieEdgePipelineOutputShape {
    edgePipelineRid: string;
}
interface ResolvedEddieGeotimeConfigurationInputShape {
    destinations: Array<EddieGeotimeDestination>;
    observationSpecId?: string | null | undefined;
    peeredDestinations: Array<EddiePeeredGeotimeDestination>;
    sourceSystemSpecId?: string | null | undefined;
}
interface ResolvedEddieParameter_primitive {
    type: "primitive";
    primitive: ResolvedEddiePrimitiveParameter;
}
type ResolvedEddieParameter = ResolvedEddieParameter_primitive;
/**
 * DEPRECATED - Prefer ResolvedEddieParameterShapeV2 as it contains only supported in the UI parameter values.
 *
 * An instance of a parameter. Must match the type requested in EddieParameterShape.
 */
interface ResolvedEddieParameterShape {
    instantiation?: Parameter | null | undefined;
}
/**
 * An instance of a parameter. Must match the type requested in EddieParameterShapeV2.
 */
interface ResolvedEddieParameterShapeV2 {
    instantiation: ResolvedEddieParameter;
}
interface ResolvedEddiePrimitiveParameter_literal {
    type: "literal";
    literal: LiteralParameter;
}
interface ResolvedEddiePrimitiveParameter_regex {
    type: "regex";
    regex: RegexParameter;
}
interface ResolvedEddiePrimitiveParameter_enum {
    type: "enum";
    enum: EnumParameter;
}
/**
 * This is a subset union of ResolvedEddieParameter
 */
type ResolvedEddiePrimitiveParameter = ResolvedEddiePrimitiveParameter_literal | ResolvedEddiePrimitiveParameter_regex | ResolvedEddiePrimitiveParameter_enum;
interface ResolvedEddieReplayOption_resetAndReplayFromOffset {
    type: "resetAndReplayFromOffset";
    resetAndReplayFromOffset: EddieResetAndReplayFromOffsetOption;
}
interface ResolvedEddieReplayOption_reset {
    type: "reset";
    reset: EddieResetOption;
}
interface ResolvedEddieReplayOption_acknowledgeStateBreaks {
    type: "acknowledgeStateBreaks";
    acknowledgeStateBreaks: EddieAcknowledgeStateBreakOption;
}
type ResolvedEddieReplayOption = ResolvedEddieReplayOption_resetAndReplayFromOffset | ResolvedEddieReplayOption_reset | ResolvedEddieReplayOption_acknowledgeStateBreaks;
interface ResolvedEddieReplayOptionShape {
    replayOption: ResolvedEddieReplayOption;
}
interface ResolvedEdgePipelineMagritteSourceInputShape {
    config: EdgeMagritteSourceConfig;
    credentialId?: NamedCredentialIdentifier | null | undefined;
    magritteSourceRid?: MagritteSourceRid | null | undefined;
    portConfig?: EdgeMagrittePortConfig | null | undefined;
    taskConfig?: EdgeMagritteTaskConfig | null | undefined;
}
interface ResolvedFilesDatasourceShape {
    dataset: DatasetLocator;
    datasource?: FilesDatasourceLocator | null | undefined;
}
interface ResolvedFlinkProfile {
    name: FlinkProfileName;
}
interface ResolvedFunctionConfigurationShape {
    functionRid: FunctionRid;
    functionVersion: FunctionVersion;
}
interface ResolvedFunctionContractShape {
    rid: FunctionContractRid;
    version: FunctionContractVersion;
}
interface ResolvedFunctionInputShape {
    apiName?: FunctionApiName | null | undefined;
    functionRid: FunctionRid;
    functionVersion: FunctionVersion;
}
interface ResolvedFunctionOutputShape {
    apiName?: FunctionApiName | null | undefined;
    functionRid: FunctionRid;
    functionVersion: FunctionVersion;
}
interface ResolvedFunctionPackageCandidateLocator {
    functionRid: FunctionRid;
    functionVersion: FunctionVersion;
    repositoryRid: AuthoringRepositoryRid;
}
interface ResolvedFunctionPackageConfigurationShape {
    packageLocator: ResolvedFunctionPackageLocator;
}
interface ResolvedFunctionPackageLocator_candidateFunction {
    type: "candidateFunction";
    candidateFunction: ResolvedFunctionPackageCandidateLocator;
}
type ResolvedFunctionPackageLocator = ResolvedFunctionPackageLocator_candidateFunction;
/**
 * This shape represents an install-time configuration that allows a user to specify how function versions and
 * API names are resolved during functions block pre-allocation.
 *
 * See FunctionsApiStabilityConfiguration for more details.
 */
interface ResolvedFunctionsApiStabilityConfigurationInputShape {
    configuration: FunctionsApiStabilityConfiguration;
}
/**
 * Deprecated: Use ResolvedFunctionsApiStabilityConfigurationInputShape instead.
 *
 * This shape represents an install-time configuration that allows a user to specify how function versions are
 * chosen during block pre-allocation when installing or upgrading a Marketplace package.
 *
 * See PreserveFunctionVersionsConfiguration for more details.
 */
interface ResolvedFunctionVersionsConfigurationInputShape {
    configuration: FunctionVersionsConfiguration;
}
interface ResolvedGeotimeSeriesIntegrationShape {
    integrationRid: GeotimeSeriesIntegrationRid;
}
/**
 * Represents the state of each group. If a resolved group is not specified then it is considered enabled.
 */
interface ResolvedInputGroup {
    enabled: boolean;
}
interface ResolvedInputOrRef_resolvedInputShape {
    type: "resolvedInputShape";
    resolvedInputShape: ResolvedInputShape;
}
interface ResolvedInputOrRef_referenceOtherOutput {
    type: "referenceOtherOutput";
    referenceOtherOutput: OutputReference;
}
interface ResolvedInputOrRef_referenceExistingOutputInStore {
    type: "referenceExistingOutputInStore";
    referenceExistingOutputInStore: BlockInstallationOutputReference;
}
/**
 * Block-level resolved input. Counterpart of `ResolvedBlockSetInputOrRef`.
 */
type ResolvedInputOrRef = ResolvedInputOrRef_resolvedInputShape | ResolvedInputOrRef_referenceOtherOutput | ResolvedInputOrRef_referenceExistingOutputInStore;
interface ResolvedInputShape_action {
    type: "action";
    action: ResolvedActionTypeShape;
}
interface ResolvedInputShape_actionParameter {
    type: "actionParameter";
    actionParameter: ResolvedActionTypeParameterShape;
}
interface ResolvedInputShape_allowOntologySchemaMigrations {
    type: "allowOntologySchemaMigrations";
    allowOntologySchemaMigrations: ResolvedAllowOntologySchemaMigrationsShape;
}
interface ResolvedInputShape_aipAgent {
    type: "aipAgent";
    aipAgent: ResolvedAipAgentShape;
}
interface ResolvedInputShape_artifactsRepository {
    type: "artifactsRepository";
    artifactsRepository: RidResolvedShape;
}
interface ResolvedInputShape_authoringLibrary {
    type: "authoringLibrary";
    authoringLibrary: ResolvedAuthoringLibraryShape;
}
interface ResolvedInputShape_authoringRepository {
    type: "authoringRepository";
    authoringRepository: RidResolvedShape;
}
interface ResolvedInputShape_automation {
    type: "automation";
    automation: ResolvedAutomationShape;
}
interface ResolvedInputShape_autopilotWorkbench {
    type: "autopilotWorkbench";
    autopilotWorkbench: RidResolvedShape;
}
interface ResolvedInputShape_blobsterResource {
    type: "blobsterResource";
    blobsterResource: RidResolvedShape;
}
interface ResolvedInputShape_carbonWorkspace {
    type: "carbonWorkspace";
    carbonWorkspace: RidResolvedShape;
}
interface ResolvedInputShape_cipherChannel {
    type: "cipherChannel";
    cipherChannel: RidResolvedShape;
}
interface ResolvedInputShape_cipherLicense {
    type: "cipherLicense";
    cipherLicense: ResolvedCipherLicenseShape;
}
interface ResolvedInputShape_cipherLicenseV2 {
    type: "cipherLicenseV2";
    cipherLicenseV2: RidResolvedShape;
}
interface ResolvedInputShape_codeWorkspace {
    type: "codeWorkspace";
    codeWorkspace: ResolvedCodeWorkspaceInputShape;
}
interface ResolvedInputShape_codeWorkspaceLicense {
    type: "codeWorkspaceLicense";
    codeWorkspaceLicense: ResolvedCodeWorkspaceLicenseInputShape;
}
interface ResolvedInputShape_compassResource {
    type: "compassResource";
    compassResource: RidResolvedShape;
}
interface ResolvedInputShape_contourAnalysis {
    type: "contourAnalysis";
    contourAnalysis: ResolvedContourAnalysisShape;
}
interface ResolvedInputShape_contourRef {
    type: "contourRef";
    contourRef: ResolvedContourRefShape;
}
interface ResolvedInputShape_dataHealthCheck {
    type: "dataHealthCheck";
    dataHealthCheck: RidResolvedShape;
}
interface ResolvedInputShape_dataHealthCheckGroup {
    type: "dataHealthCheckGroup";
    dataHealthCheckGroup: RidResolvedShape;
}
interface ResolvedInputShape_datasourceColumn {
    type: "datasourceColumn";
    datasourceColumn: ResolvedDatasourceColumnShape;
}
interface ResolvedInputShape_deployedApp {
    type: "deployedApp";
    deployedApp: RidResolvedShape;
}
interface ResolvedInputShape_eddieParameter {
    type: "eddieParameter";
    eddieParameter: ResolvedEddieParameterShape;
}
interface ResolvedInputShape_eddieParameterV2 {
    type: "eddieParameterV2";
    eddieParameterV2: ResolvedEddieParameterShapeV2;
}
interface ResolvedInputShape_eddiePipeline {
    type: "eddiePipeline";
    eddiePipeline: RidResolvedShape;
}
interface ResolvedInputShape_eddieReplayOption {
    type: "eddieReplayOption";
    eddieReplayOption: ResolvedEddieReplayOptionShape;
}
interface ResolvedInputShape_eddieGeotimeConfiguration {
    type: "eddieGeotimeConfiguration";
    eddieGeotimeConfiguration: ResolvedEddieGeotimeConfigurationInputShape;
}
interface ResolvedInputShape_eddieEdgeParameter {
    type: "eddieEdgeParameter";
    eddieEdgeParameter: ResolvedEddieEdgeParameterShape;
}
interface ResolvedInputShape_edgePipelineMagritteSource {
    type: "edgePipelineMagritteSource";
    edgePipelineMagritteSource: ResolvedEdgePipelineMagritteSourceInputShape;
}
interface ResolvedInputShape_evaluationSuite {
    type: "evaluationSuite";
    evaluationSuite: RidResolvedShape;
}
interface ResolvedInputShape_filesDatasource {
    type: "filesDatasource";
    filesDatasource: ResolvedFilesDatasourceShape;
}
interface ResolvedInputShape_flinkProfile {
    type: "flinkProfile";
    flinkProfile: ResolvedFlinkProfile;
}
interface ResolvedInputShape_function {
    type: "function";
    function: ResolvedFunctionInputShape;
}
interface ResolvedInputShape_functionContract {
    type: "functionContract";
    functionContract: ResolvedFunctionContractShape;
}
interface ResolvedInputShape_functionVersionsConfiguration {
    type: "functionVersionsConfiguration";
    functionVersionsConfiguration: ResolvedFunctionVersionsConfigurationInputShape;
}
interface ResolvedInputShape_functionsApiStabilityConfiguration {
    type: "functionsApiStabilityConfiguration";
    functionsApiStabilityConfiguration: ResolvedFunctionsApiStabilityConfigurationInputShape;
}
interface ResolvedInputShape_fusionDocument {
    type: "fusionDocument";
    fusionDocument: RidResolvedShape;
}
interface ResolvedInputShape_geotimeSeriesIntegration {
    type: "geotimeSeriesIntegration";
    geotimeSeriesIntegration: ResolvedGeotimeSeriesIntegrationShape;
}
interface ResolvedInputShape_interfaceType {
    type: "interfaceType";
    interfaceType: ResolvedInterfaceTypeShape;
}
interface ResolvedInputShape_interfaceLinkType {
    type: "interfaceLinkType";
    interfaceLinkType: ResolvedInterfaceLinkTypeShape;
}
interface ResolvedInputShape_interfacePropertyType {
    type: "interfacePropertyType";
    interfacePropertyType: ResolvedInterfacePropertyTypeShape;
}
interface ResolvedInputShape_interfaceActionTypeConstraint {
    type: "interfaceActionTypeConstraint";
    interfaceActionTypeConstraint: ResolvedInterfaceActionTypeConstraintShape;
}
interface ResolvedInputShape_interfaceParameterConstraint {
    type: "interfaceParameterConstraint";
    interfaceParameterConstraint: ResolvedInterfaceParameterConstraintShape;
}
interface ResolvedInputShape_installPrefix {
    type: "installPrefix";
    installPrefix: ResolvedInstallPrefixShape;
}
interface ResolvedInputShape_languageModel {
    type: "languageModel";
    languageModel: ResolvedLanguageModelShape;
}
interface ResolvedInputShape_linkType {
    type: "linkType";
    linkType: ResolvedLinkTypeInputShape;
}
interface ResolvedInputShape_logic {
    type: "logic";
    logic: RidResolvedShape;
}
interface ResolvedInputShape_logicFunction {
    type: "logicFunction";
    logicFunction: ResolvedLogicFunctionShape;
}
interface ResolvedInputShape_machinery {
    type: "machinery";
    machinery: ResolvedMachineryProcessShape;
}
interface ResolvedInputShape_magritteConnection {
    type: "magritteConnection";
    magritteConnection: ResolvedMagritteConnectionInputShape;
}
interface ResolvedInputShape_magritteExport {
    type: "magritteExport";
    magritteExport: ResolvedMagritteExportShape;
}
interface ResolvedInputShape_magritteSource {
    type: "magritteSource";
    magritteSource: ResolvedMagritteSourceInputShape;
}
interface ResolvedInputShape_magritteSourceConfigOverrides {
    type: "magritteSourceConfigOverrides";
    magritteSourceConfigOverrides: ResolvedMagritteSourceConfigOverridesInputShape;
}
interface ResolvedInputShape_magritteStreamingExtractConfigOverrides {
    type: "magritteStreamingExtractConfigOverrides";
    magritteStreamingExtractConfigOverrides: ResolvedMagritteStreamingExtractConfigOverridesInputShape;
}
interface ResolvedInputShape_markings {
    type: "markings";
    markings: ResolvedMarkingsShape;
}
interface ResolvedInputShape_modelStudio {
    type: "modelStudio";
    modelStudio: RidResolvedShape;
}
interface ResolvedInputShape_multipassUserAttribute {
    type: "multipassUserAttribute";
    multipassUserAttribute: ResolvedMultipassUserAttributeShape;
}
interface ResolvedInputShape_multipassGroup {
    type: "multipassGroup";
    multipassGroup: ResolvedMultipassGroupShape;
}
interface ResolvedInputShape_model {
    type: "model";
    model: ResolvedModelInputShape;
}
interface ResolvedInputShape_monitorView {
    type: "monitorView";
    monitorView: RidResolvedShape;
}
interface ResolvedInputShape_monocleGraph {
    type: "monocleGraph";
    monocleGraph: RidResolvedShape;
}
interface ResolvedInputShape_namedCredential {
    type: "namedCredential";
    namedCredential: RidResolvedShape;
}
interface ResolvedInputShape_networkEgressPolicy {
    type: "networkEgressPolicy";
    networkEgressPolicy: RidResolvedShape;
}
interface ResolvedInputShape_notepadDocument {
    type: "notepadDocument";
    notepadDocument: RidResolvedShape;
}
interface ResolvedInputShape_notepadTemplate {
    type: "notepadTemplate";
    notepadTemplate: ResolvedNotepadTemplateShape;
}
interface ResolvedInputShape_notepadTemplateParameter {
    type: "notepadTemplateParameter";
    notepadTemplateParameter: ResolvedNotepadTemplateParameterShape;
}
interface ResolvedInputShape_objectInstance {
    type: "objectInstance";
    objectInstance: ResolvedObjectInstanceShape;
}
interface ResolvedInputShape_objectSet {
    type: "objectSet";
    objectSet: ResolvedObjectSetShape;
}
interface ResolvedInputShape_objectType {
    type: "objectType";
    objectType: ResolvedObjectTypeShape;
}
interface ResolvedInputShape_objectView {
    type: "objectView";
    objectView: ResolvedObjectViewShape;
}
interface ResolvedInputShape_objectViewTab {
    type: "objectViewTab";
    objectViewTab: ResolvedObjectViewTabShape;
}
interface ResolvedInputShape_ontologyDatasource {
    type: "ontologyDatasource";
    ontologyDatasource: ResolvedOntologyDatasourceShape;
}
interface ResolvedInputShape_ontologyDatasourceRetention {
    type: "ontologyDatasourceRetention";
    ontologyDatasourceRetention: ResolvedOntologyDatasourceRetentionShape;
}
interface ResolvedInputShape_ontologySdk {
    type: "ontologySdk";
    ontologySdk: ResolvedOntologySdkShape;
}
interface ResolvedInputShape_overrideOntologyEntityApiNames {
    type: "overrideOntologyEntityApiNames";
    overrideOntologyEntityApiNames: ResolvedOverrideOntologyEntityApiNamesShape;
}
interface ResolvedInputShape_parameter {
    type: "parameter";
    parameter: ResolvedParameterInputShape;
}
interface ResolvedInputShape_peerProducerProfile {
    type: "peerProducerProfile";
    peerProducerProfile: ResolvedPeerProducerProfileShape;
}
interface ResolvedInputShape_peerProfile {
    type: "peerProfile";
    peerProfile: RidResolvedShape;
}
interface ResolvedInputShape_peerProfileRemoteStrategy {
    type: "peerProfileRemoteStrategy";
    peerProfileRemoteStrategy: ResolvedPeerProfileRemoteStrategyShape;
}
interface ResolvedInputShape_property {
    type: "property";
    property: ResolvedPropertyShape;
}
interface ResolvedInputShape_quiverDashboard {
    type: "quiverDashboard";
    quiverDashboard: ResolvedQuiverDashboardShape;
}
interface ResolvedInputShape_schedule {
    type: "schedule";
    schedule: ResolvedScheduleShape;
}
interface ResolvedInputShape_sharedPropertyType {
    type: "sharedPropertyType";
    sharedPropertyType: ResolvedSharedPropertyTypeShape;
}
interface ResolvedInputShape_slateApplication {
    type: "slateApplication";
    slateApplication: RidResolvedShape;
}
interface ResolvedInputShape_storedProcedure {
    type: "storedProcedure";
    storedProcedure: ResolvedStoredProcedureShape;
}
interface ResolvedInputShape_solutionDesign {
    type: "solutionDesign";
    solutionDesign: ResolvedSolutionDesignShape;
}
interface ResolvedInputShape_sparkProfile {
    type: "sparkProfile";
    sparkProfile: ResolvedSparkProfile;
}
interface ResolvedInputShape_tabularDatasource {
    type: "tabularDatasource";
    tabularDatasource: ResolvedDatasourceShape;
}
interface ResolvedInputShape_taurusWorkflow {
    type: "taurusWorkflow";
    taurusWorkflow: RidResolvedShape;
}
interface ResolvedInputShape_thirdPartyApplication {
    type: "thirdPartyApplication";
    thirdPartyApplication: ResolvedThirdPartyApplicationShape;
}
interface ResolvedInputShape_timeSeriesSync {
    type: "timeSeriesSync";
    timeSeriesSync: ResolvedTimeSeriesSyncShape;
}
interface ResolvedInputShape_valueType {
    type: "valueType";
    valueType: ResolvedValueTypeShape;
}
interface ResolvedInputShape_vectorWorkbook {
    type: "vectorWorkbook";
    vectorWorkbook: RidResolvedShape;
}
interface ResolvedInputShape_versionedObjectSet {
    type: "versionedObjectSet";
    versionedObjectSet: ResolvedVersionedObjectSetShape;
}
interface ResolvedInputShape_vertexTemplate {
    type: "vertexTemplate";
    vertexTemplate: ResolvedVertexTemplateShape;
}
interface ResolvedInputShape_vortexTemplate {
    type: "vortexTemplate";
    vortexTemplate: ResolvedVortexTemplateShape;
}
interface ResolvedInputShape_walkthrough {
    type: "walkthrough";
    walkthrough: ResolvedWalkthroughShape;
}
interface ResolvedInputShape_webhook {
    type: "webhook";
    webhook: ResolvedWebhookInputShape;
}
interface ResolvedInputShape_widget {
    type: "widget";
    widget: ResolvedWidgetShape;
}
interface ResolvedInputShape_widgetSet {
    type: "widgetSet";
    widgetSet: ResolvedWidgetSetShape;
}
interface ResolvedInputShape_workbenchTemplate {
    type: "workbenchTemplate";
    workbenchTemplate: RidResolvedShape;
}
interface ResolvedInputShape_workflowBuilderGraph {
    type: "workflowBuilderGraph";
    workflowBuilderGraph: RidResolvedShape;
}
interface ResolvedInputShape_workflowGraph {
    type: "workflowGraph";
    workflowGraph: RidResolvedShape;
}
interface ResolvedInputShape_sqlWorksheet {
    type: "sqlWorksheet";
    sqlWorksheet: ResolvedSqlWorksheetShape;
}
interface ResolvedInputShape_workshopApplication {
    type: "workshopApplication";
    workshopApplication: RidResolvedShape;
}
interface ResolvedInputShape_workshopApplicationSaveLocation {
    type: "workshopApplicationSaveLocation";
    workshopApplicationSaveLocation: ResolvedWorkshopApplicationSaveLocationInputShape;
}
/**
 * Resolved versions of the ``InputShape``. These contain references to actual entities that should satisfy
 * the (unresolved) input shape. A ``ResolvedInputShape`` typically contains the same information as a ``ResolvedOutputShape``,
 * but contains a superset of the information in certain cases, in order to provide the necessary information
 * for installers (this only applies to `ResolvedLinkTypeInputShape` as of October 2023).
 */
type ResolvedInputShape = ResolvedInputShape_action | ResolvedInputShape_actionParameter | ResolvedInputShape_allowOntologySchemaMigrations | ResolvedInputShape_aipAgent | ResolvedInputShape_artifactsRepository | ResolvedInputShape_authoringLibrary | ResolvedInputShape_authoringRepository | ResolvedInputShape_automation | ResolvedInputShape_autopilotWorkbench | ResolvedInputShape_blobsterResource | ResolvedInputShape_carbonWorkspace | ResolvedInputShape_cipherChannel | ResolvedInputShape_cipherLicense | ResolvedInputShape_cipherLicenseV2 | ResolvedInputShape_codeWorkspace | ResolvedInputShape_codeWorkspaceLicense | ResolvedInputShape_compassResource | ResolvedInputShape_contourAnalysis | ResolvedInputShape_contourRef | ResolvedInputShape_dataHealthCheck | ResolvedInputShape_dataHealthCheckGroup | ResolvedInputShape_datasourceColumn | ResolvedInputShape_deployedApp | ResolvedInputShape_eddieParameter | ResolvedInputShape_eddieParameterV2 | ResolvedInputShape_eddiePipeline | ResolvedInputShape_eddieReplayOption | ResolvedInputShape_eddieGeotimeConfiguration | ResolvedInputShape_eddieEdgeParameter | ResolvedInputShape_edgePipelineMagritteSource | ResolvedInputShape_evaluationSuite | ResolvedInputShape_filesDatasource | ResolvedInputShape_flinkProfile | ResolvedInputShape_function | ResolvedInputShape_functionContract | ResolvedInputShape_functionVersionsConfiguration | ResolvedInputShape_functionsApiStabilityConfiguration | ResolvedInputShape_fusionDocument | ResolvedInputShape_geotimeSeriesIntegration | ResolvedInputShape_interfaceType | ResolvedInputShape_interfaceLinkType | ResolvedInputShape_interfacePropertyType | ResolvedInputShape_interfaceActionTypeConstraint | ResolvedInputShape_interfaceParameterConstraint | ResolvedInputShape_installPrefix | ResolvedInputShape_languageModel | ResolvedInputShape_linkType | ResolvedInputShape_logic | ResolvedInputShape_logicFunction | ResolvedInputShape_machinery | ResolvedInputShape_magritteConnection | ResolvedInputShape_magritteExport | ResolvedInputShape_magritteSource | ResolvedInputShape_magritteSourceConfigOverrides | ResolvedInputShape_magritteStreamingExtractConfigOverrides | ResolvedInputShape_markings | ResolvedInputShape_modelStudio | ResolvedInputShape_multipassUserAttribute | ResolvedInputShape_multipassGroup | ResolvedInputShape_model | ResolvedInputShape_monitorView | ResolvedInputShape_monocleGraph | ResolvedInputShape_namedCredential | ResolvedInputShape_networkEgressPolicy | ResolvedInputShape_notepadDocument | ResolvedInputShape_notepadTemplate | ResolvedInputShape_notepadTemplateParameter | ResolvedInputShape_objectInstance | ResolvedInputShape_objectSet | ResolvedInputShape_objectType | ResolvedInputShape_objectView | ResolvedInputShape_objectViewTab | ResolvedInputShape_ontologyDatasource | ResolvedInputShape_ontologyDatasourceRetention | ResolvedInputShape_ontologySdk | ResolvedInputShape_overrideOntologyEntityApiNames | ResolvedInputShape_parameter | ResolvedInputShape_peerProducerProfile | ResolvedInputShape_peerProfile | ResolvedInputShape_peerProfileRemoteStrategy | ResolvedInputShape_property | ResolvedInputShape_quiverDashboard | ResolvedInputShape_schedule | ResolvedInputShape_sharedPropertyType | ResolvedInputShape_slateApplication | ResolvedInputShape_storedProcedure | ResolvedInputShape_solutionDesign | ResolvedInputShape_sparkProfile | ResolvedInputShape_tabularDatasource | ResolvedInputShape_taurusWorkflow | ResolvedInputShape_thirdPartyApplication | ResolvedInputShape_timeSeriesSync | ResolvedInputShape_valueType | ResolvedInputShape_vectorWorkbook | ResolvedInputShape_versionedObjectSet | ResolvedInputShape_vertexTemplate | ResolvedInputShape_vortexTemplate | ResolvedInputShape_walkthrough | ResolvedInputShape_webhook | ResolvedInputShape_widget | ResolvedInputShape_widgetSet | ResolvedInputShape_workbenchTemplate | ResolvedInputShape_workflowBuilderGraph | ResolvedInputShape_workflowGraph | ResolvedInputShape_sqlWorksheet | ResolvedInputShape_workshopApplication | ResolvedInputShape_workshopApplicationSaveLocation;
/**
 * A block set installation in the draft with fully computed inputs that combine manually provided inputs and
 * inputs automatically mapped by the backend.
 */
interface ResolvedInstallation {
    appliedRecommendations: Array<UpstreamRecommendation>;
    installationRid: BlockSetInstallationRid;
    resolvedInputShapes: Record<InputBlockSetShapeId, BlockSetInstallationResolvedInputV3>;
    resolvedOutputShapesToAttach: Record<OutputBlockSetShapeId, ResolvedBlockSetOutputShape>;
    targetVersion: InstallableBlockSetVersionId;
}
/**
 * See docs of `InstallPrefixShape` for details.
 */
interface ResolvedInstallPrefixShape {
    prefix: string;
    prefixConfiguration?: InstallPrefixConfigurationEnum | null | undefined;
}
interface ResolvedInterfaceActionTypeConstraintReferenceMismatch {
    actual: InterfaceActionTypeConstraintReference;
    expected: InterfaceActionTypeConstraintReference;
    interfaceTypeRid: InterfaceTypeRid;
}
/**
 * Resolved version of the InterfaceActionTypeConstraintShape. References the actual
 * InterfaceActionTypeConstraint the shape corresponds to.
 */
interface ResolvedInterfaceActionTypeConstraintShape {
    apiName: InterfaceActionTypeConstraintApiName;
    interfaceTypeRid: InterfaceTypeRid;
    ontologyRid: OntologyRid;
    rid: InterfaceActionTypeConstraintRid;
}
/**
 * Resolved version of the InterfaceLinkTypeShape. References the actual InterfaceLinkType the shape corresponds
 * to.
 */
interface ResolvedInterfaceLinkTypeShape {
    apiName: InterfaceLinkTypeApiName;
    interfaceType: InterfaceTypeRid;
    ontologyRid: OntologyRid;
    rid: InterfaceLinkTypeRid;
}
/**
 * Resolved version of the InterfaceParameterConstraintShape. References the actual
 * InterfaceParameterConstraint the shape corresponds to.
 */
interface ResolvedInterfaceParameterConstraintShape {
    actionTypeConstraint: InterfaceActionTypeConstraintRid;
    interfaceTypeRid: InterfaceTypeRid;
    ontologyRid: OntologyRid;
    rid: InterfaceParameterConstraintRid;
}
/**
 * Resolved version of the InterfacePropertyTypeShape. References the actual InterfacePropertyType the shape
 * corresponds to.
 */
interface ResolvedInterfacePropertyTypeShape {
    apiName: InterfacePropertyTypeApiName;
    interfaceType: InterfaceTypeRid;
    ontologyRid: OntologyRid;
    rid: InterfacePropertyTypeRid;
    structFieldRids: Record<ObjectTypeFieldApiName, StructFieldRid>;
}
/**
 * Shape id that was resolved for the parent InterfaceType does not match the shape id expected.
 */
interface ResolvedInterfaceTypeReferenceMismatch {
    actual: InterfaceTypeReference;
    expected: InterfaceTypeReference;
}
/**
 * Resolved version of the InterfaceTypeShape. References the actual InterfaceType the shape corresponds with.
 */
interface ResolvedInterfaceTypeShape {
    apiName?: InterfaceTypeApiName | null | undefined;
    ontologyRid: OntologyRid;
    rid: InterfaceTypeRid;
}
/**
 * Contains references to the actual ObjectType(s) and LinkType(s) involved in the intermediary link type.
 */
interface ResolvedIntermediaryLinkOntologyTypes {
    intermediaryObjectTypeRid: ObjectTypeRid;
    linkTypeARid: LinkTypeRid;
    linkTypeBRid: LinkTypeRid;
    objectTypeARid: ObjectTypeRid;
    objectTypeBRid: ObjectTypeRid;
}
/**
 * The ResolvedIntermediaryLinkOntologyTypes provided as part of the resolved LinkType shape is not
 * consistent with the underlying Intermediary link type.
 */
interface ResolvedIntermediaryLinkOntologyTypesInconsistent {
    actual: ResolvedIntermediaryLinkOntologyTypes;
    expected: ResolvedIntermediaryLinkOntologyTypes;
}
/**
 * An installation draft with the fully resolved state of all target installations and any validation errors.
 * This draft object is updated by asynchronous tasks. Always returns the last processed resolved installations
 * and errors. If the status is `idle`, we guarantee these are all up-to-date.
 */
interface ResolvedJobDraft {
    error?: MarketplaceSerializableError | null | undefined;
    installations: Array<ResolvedInstallation>;
    ownerValidationErrors: JobDraftOwnerValidationErrors;
    rid: BlockSetInstallationJobRid;
}
interface ResolvedLanguageModelShape {
    rid: LanguageModelRid;
}
/**
 * The ResolvedLinkedObjectTypes provided as part of the resolved LinkType shape is of an unknown type.
 */
interface ResolvedLinkedObjectTypesUnknown {
    unknownType: string;
}
interface ResolvedLinkedOntologyTypes_oneToMany {
    type: "oneToMany";
    oneToMany: ResolvedOneToManyLinkObjectTypes;
}
interface ResolvedLinkedOntologyTypes_manyToMany {
    type: "manyToMany";
    manyToMany: ResolvedManyToManyLinkObjectTypes;
}
interface ResolvedLinkedOntologyTypes_intermediary {
    type: "intermediary";
    intermediary: ResolvedIntermediaryLinkOntologyTypes;
}
/**
 * Contains references to the actual ObjectType(s) and LinkType(s) involved in the link type.
 */
type ResolvedLinkedOntologyTypes = ResolvedLinkedOntologyTypes_oneToMany | ResolvedLinkedOntologyTypes_manyToMany | ResolvedLinkedOntologyTypes_intermediary;
/**
 * Resolved version of the LinkTypeShape. Contains references to the actual LinkType created for the shape.
 */
interface ResolvedLinkTypeInputShape {
    apiNames?: LinkTypeApiNames | null | undefined;
    id: LinkTypeId;
    linkedObjectTypes: ResolvedLinkedOntologyTypes;
    ontologyRid: OntologyRid;
    rid: LinkTypeRid;
}
/**
 * Resolved version of the LinkTypeShape. Contains references to the actual LinkType created for the shape.
 */
interface ResolvedLinkTypeOutputShape {
    apiNames?: LinkTypeApiNames | null | undefined;
    id: LinkTypeId;
    ontologyRid: OntologyRid;
    rid: LinkTypeRid;
}
/**
 * Shape Id that was resolved for the LinkType does not match the shape id expected.
 */
interface ResolvedLinkTypeReferenceMismatch {
    actual: LinkTypeReference;
    expected: LinkTypeReference;
}
interface ResolvedLogicFunctionShape {
    functionId: LogicFunctionId;
    functionVersion: LogicFunctionVersion;
    logicRid: LogicRid;
}
interface ResolvedMachineryProcessShape {
    machineryProcessRid: MachineryProcessRid;
}
interface ResolvedMagritteConnectionInputShape {
    connectionId: MagritteConnectionId;
    sourceRid: MagritteSourceRid;
}
/**
 * Resolved shape representing a magritte export.
 */
interface ResolvedMagritteExportShape {
    exportRid: MagritteExportRid;
}
interface ResolvedMagritteExtractOutputShape {
    extractRid: MagritteExtractRid;
}
interface ResolvedMagritteSourceConfigOverridesInputShape {
    configOverrides: ConfigBlock;
}
interface ResolvedMagritteSourceInputShape {
    sourceRid: MagritteSourceRid;
}
interface ResolvedMagritteSourceOutputShape {
    sourceRid: MagritteSourceRid;
}
interface ResolvedMagritteStreamingExtractConfigOverridesInputShape {
    configOverrides: ConfigBlock;
}
interface ResolvedMagritteStreamingExtractOutputShape {
    rid: MagritteStreamingExtractRid;
}
/**
 * Contains references to the actual ObjectType(s) involved in the many to many link type.
 */
interface ResolvedManyToManyLinkObjectTypes {
    objectTypeRidA: ObjectTypeRid;
    objectTypeRidB: ObjectTypeRid;
}
/**
 * The ResolvedManyToManyLinkObjectTypes provided as part of the resolved LinkType shape is not
 * consistent with the underlying Many to Many link type.
 */
interface ResolvedManyToManyLinkObjectTypesInconsistent {
    actual: ResolvedManyToManyLinkObjectTypes;
    expected: ResolvedManyToManyLinkObjectTypes;
}
/**
 * DEPRECATED. Use "ResolvedMapRendererSetOutputShapeV2" instead.
 */
interface ResolvedMapRendererSetOutputShape {
    objectTypeRid: ObjectTypeRid;
}
interface ResolvedMapRendererSetOutputShapeV2 {
    locator: MapRendererSetLocator;
}
interface ResolvedMarkingsShape {
    markingIds: Array<MarkingId>;
    stableId?: StableShapeIdentifier | null | undefined;
}
interface ResolvedModelInputShape {
    modelRid: ModelRid;
    modelVersionRid: ModelVersionRid;
    type: ModelType;
}
interface ResolvedModelOutputShape {
    modelRid: ModelRid;
    modelVersionRid: ModelVersionRid;
    type: ModelType;
}
interface ResolvedModelStudioConfigShape {
    modelStudioConfigRid: ModelStudioConfigRid;
    modelStudioRid: ModelStudioRid;
}
interface ResolvedMultipassGroupShape {
    groupId: MultipassGroupId;
}
interface ResolvedMultipassUserAttributeShape {
    name: MultipassUserAttributeName;
}
interface ResolvedNotepadTemplateParameterShape {
    id: NotepadTemplateParameterId;
    templateRid: NotepadTemplateRid;
    templateVersion: NotepadTemplateVersion;
}
interface ResolvedNotepadTemplateShape {
    rid: NotepadTemplateRid;
    version: NotepadTemplateVersion;
}
interface ResolvedObjectInstanceShape {
    rid: ObjectRid;
}
interface ResolvedObjectSetShape {
    rid: ObjectSetRid;
}
/**
 * Shape Id that was resolved for the ObjectType does not match the shape id expected.
 */
interface ResolvedObjectTypeReferenceMismatch {
    actual: ObjectTypeReference;
    expected: ObjectTypeReference;
}
/**
 * Resolved version of the ObjectTypeShape. References the actual ObjectType that the shape corresponds to.
 */
interface ResolvedObjectTypeShape {
    apiName?: ObjectTypeApiName | null | undefined;
    id: ObjectTypeId;
    ontologyRid: OntologyRid;
    rid: ObjectTypeRid;
}
interface ResolvedObjectViewShape {
    objectTypeRid: ObjectTypeRid;
}
interface ResolvedObjectViewTabShape {
    objectTypeRid: ObjectTypeRid;
    tabId: ObjectViewTabId;
}
/**
 * Contains references to the actual ObjectType(s) involved in the one to many link type.
 */
interface ResolvedOneToManyLinkObjectTypes {
    objectTypeRidManySide: ObjectTypeRid;
    objectTypeRidOneSide: ObjectTypeRid;
}
/**
 * The ResolvedManyToManyLinkObjectTypes provided as part of the resolved LinkType shape is not
 * consistent with the underlying One To Many link type.
 */
interface ResolvedOneToManyLinkObjectTypesInconsistent {
    actual: ResolvedOneToManyLinkObjectTypes;
    expected: ResolvedOneToManyLinkObjectTypes;
}
/**
 * The retention threshold for an ontology datasource. Only applicable to direct datasources on edge
 * environments.
 *
 * note: Since MDOs are not supported for direct datasources, as of now, datasource retention and object
 * type retention is synonymous.
 */
interface ResolvedOntologyDatasourceRetentionShape {
    targetSize: number;
    triggerSize: number;
}
interface ResolvedOntologyDatasourceShape {
    datasourceRid: string;
    ontologyEntityRid: string;
}
interface ResolvedOntologySdkShape {
    rid: OntologySdkRid;
    version?: OntologySdkVersion | null | undefined;
}
interface ResolvedOntologySdkShapeV2 {
    packageName: PackageName;
    repositoryRid: ArtifactsRepositoryRid;
}
interface ResolvedOutputShape_action {
    type: "action";
    action: ResolvedActionTypeShape;
}
interface ResolvedOutputShape_actionParameter {
    type: "actionParameter";
    actionParameter: ResolvedActionTypeParameterShape;
}
interface ResolvedOutputShape_aipAgent {
    type: "aipAgent";
    aipAgent: ResolvedAipAgentShape;
}
interface ResolvedOutputShape_appConfigTitanium {
    type: "appConfigTitanium";
    appConfigTitanium: RidResolvedShape;
}
interface ResolvedOutputShape_appConfig {
    type: "appConfig";
    appConfig: RidResolvedShape;
}
interface ResolvedOutputShape_artifactsRepository {
    type: "artifactsRepository";
    artifactsRepository: RidResolvedShape;
}
interface ResolvedOutputShape_authoringLibrary {
    type: "authoringLibrary";
    authoringLibrary: ResolvedAuthoringLibraryShape;
}
interface ResolvedOutputShape_authoringRepository {
    type: "authoringRepository";
    authoringRepository: RidResolvedShape;
}
interface ResolvedOutputShape_automation {
    type: "automation";
    automation: ResolvedAutomationShape;
}
interface ResolvedOutputShape_autopilotWorkbench {
    type: "autopilotWorkbench";
    autopilotWorkbench: RidResolvedShape;
}
interface ResolvedOutputShape_blobsterResource {
    type: "blobsterResource";
    blobsterResource: RidResolvedShape;
}
interface ResolvedOutputShape_carbonWorkspace {
    type: "carbonWorkspace";
    carbonWorkspace: RidResolvedShape;
}
interface ResolvedOutputShape_checkpointConfig {
    type: "checkpointConfig";
    checkpointConfig: RidResolvedShape;
}
interface ResolvedOutputShape_cipherChannel {
    type: "cipherChannel";
    cipherChannel: RidResolvedShape;
}
interface ResolvedOutputShape_cipherLicense {
    type: "cipherLicense";
    cipherLicense: RidResolvedShape;
}
interface ResolvedOutputShape_codeWorkspace {
    type: "codeWorkspace";
    codeWorkspace: ResolvedCodeWorkspaceOutputShape;
}
interface ResolvedOutputShape_compassResource {
    type: "compassResource";
    compassResource: RidResolvedShape;
}
interface ResolvedOutputShape_contourAnalysis {
    type: "contourAnalysis";
    contourAnalysis: ResolvedContourAnalysisShape;
}
interface ResolvedOutputShape_contourRef {
    type: "contourRef";
    contourRef: ResolvedContourRefShape;
}
interface ResolvedOutputShape_dataHealthCheck {
    type: "dataHealthCheck";
    dataHealthCheck: RidResolvedShape;
}
interface ResolvedOutputShape_dataHealthCheckGroup {
    type: "dataHealthCheckGroup";
    dataHealthCheckGroup: RidResolvedShape;
}
interface ResolvedOutputShape_datasourceColumn {
    type: "datasourceColumn";
    datasourceColumn: ResolvedDatasourceColumnShape;
}
interface ResolvedOutputShape_deployedApp {
    type: "deployedApp";
    deployedApp: RidResolvedShape;
}
interface ResolvedOutputShape_eddieEdgePipeline {
    type: "eddieEdgePipeline";
    eddieEdgePipeline: ResolvedEddieEdgePipelineOutputShape;
}
interface ResolvedOutputShape_eddiePipeline {
    type: "eddiePipeline";
    eddiePipeline: RidResolvedShape;
}
interface ResolvedOutputShape_evaluationSuite {
    type: "evaluationSuite";
    evaluationSuite: RidResolvedShape;
}
interface ResolvedOutputShape_filesDatasource {
    type: "filesDatasource";
    filesDatasource: ResolvedFilesDatasourceShape;
}
interface ResolvedOutputShape_function {
    type: "function";
    function: ResolvedFunctionOutputShape;
}
interface ResolvedOutputShape_functionConfiguration {
    type: "functionConfiguration";
    functionConfiguration: ResolvedFunctionConfigurationShape;
}
interface ResolvedOutputShape_functionPackageConfiguration {
    type: "functionPackageConfiguration";
    functionPackageConfiguration: ResolvedFunctionPackageConfigurationShape;
}
interface ResolvedOutputShape_geotimeSeriesIntegration {
    type: "geotimeSeriesIntegration";
    geotimeSeriesIntegration: ResolvedGeotimeSeriesIntegrationShape;
}
interface ResolvedOutputShape_interfaceType {
    type: "interfaceType";
    interfaceType: ResolvedInterfaceTypeShape;
}
interface ResolvedOutputShape_interfaceLinkType {
    type: "interfaceLinkType";
    interfaceLinkType: ResolvedInterfaceLinkTypeShape;
}
interface ResolvedOutputShape_interfacePropertyType {
    type: "interfacePropertyType";
    interfacePropertyType: ResolvedInterfacePropertyTypeShape;
}
interface ResolvedOutputShape_interfaceActionTypeConstraint {
    type: "interfaceActionTypeConstraint";
    interfaceActionTypeConstraint: ResolvedInterfaceActionTypeConstraintShape;
}
interface ResolvedOutputShape_interfaceParameterConstraint {
    type: "interfaceParameterConstraint";
    interfaceParameterConstraint: ResolvedInterfaceParameterConstraintShape;
}
interface ResolvedOutputShape_linkType {
    type: "linkType";
    linkType: ResolvedLinkTypeOutputShape;
}
interface ResolvedOutputShape_logic {
    type: "logic";
    logic: RidResolvedShape;
}
interface ResolvedOutputShape_logicFunction {
    type: "logicFunction";
    logicFunction: ResolvedLogicFunctionShape;
}
interface ResolvedOutputShape_machinery {
    type: "machinery";
    machinery: ResolvedMachineryProcessShape;
}
interface ResolvedOutputShape_magritteExport {
    type: "magritteExport";
    magritteExport: ResolvedMagritteExportShape;
}
interface ResolvedOutputShape_magritteExtract {
    type: "magritteExtract";
    magritteExtract: ResolvedMagritteExtractOutputShape;
}
interface ResolvedOutputShape_magritteSource {
    type: "magritteSource";
    magritteSource: ResolvedMagritteSourceOutputShape;
}
interface ResolvedOutputShape_magritteStreamingExtract {
    type: "magritteStreamingExtract";
    magritteStreamingExtract: ResolvedMagritteStreamingExtractOutputShape;
}
interface ResolvedOutputShape_modelStudio {
    type: "modelStudio";
    modelStudio: RidResolvedShape;
}
interface ResolvedOutputShape_modelStudioConfig {
    type: "modelStudioConfig";
    modelStudioConfig: ResolvedModelStudioConfigShape;
}
interface ResolvedOutputShape_model {
    type: "model";
    model: ResolvedModelOutputShape;
}
interface ResolvedOutputShape_monitor {
    type: "monitor";
    monitor: RidResolvedShape;
}
interface ResolvedOutputShape_monitorView {
    type: "monitorView";
    monitorView: RidResolvedShape;
}
interface ResolvedOutputShape_mapRendererSet {
    type: "mapRendererSet";
    mapRendererSet: ResolvedMapRendererSetOutputShape;
}
interface ResolvedOutputShape_mapRendererSetV2 {
    type: "mapRendererSetV2";
    mapRendererSetV2: ResolvedMapRendererSetOutputShapeV2;
}
interface ResolvedOutputShape_namedCredential {
    type: "namedCredential";
    namedCredential: RidResolvedShape;
}
interface ResolvedOutputShape_networkEgressPolicy {
    type: "networkEgressPolicy";
    networkEgressPolicy: RidResolvedShape;
}
interface ResolvedOutputShape_normalizationMaxClassification {
    type: "normalizationMaxClassification";
    normalizationMaxClassification: RidResolvedShape;
}
interface ResolvedOutputShape_notepadDocument {
    type: "notepadDocument";
    notepadDocument: RidResolvedShape;
}
interface ResolvedOutputShape_notepadTemplate {
    type: "notepadTemplate";
    notepadTemplate: ResolvedNotepadTemplateShape;
}
interface ResolvedOutputShape_notepadTemplateParameter {
    type: "notepadTemplateParameter";
    notepadTemplateParameter: ResolvedNotepadTemplateParameterShape;
}
interface ResolvedOutputShape_objectSet {
    type: "objectSet";
    objectSet: ResolvedObjectSetShape;
}
interface ResolvedOutputShape_objectType {
    type: "objectType";
    objectType: ResolvedObjectTypeShape;
}
interface ResolvedOutputShape_objectView {
    type: "objectView";
    objectView: ResolvedObjectViewShape;
}
interface ResolvedOutputShape_objectViewTab {
    type: "objectViewTab";
    objectViewTab: ResolvedObjectViewTabShape;
}
interface ResolvedOutputShape_ontologySdk {
    type: "ontologySdk";
    ontologySdk: ResolvedOntologySdkShape;
}
interface ResolvedOutputShape_ontologySdkV2 {
    type: "ontologySdkV2";
    ontologySdkV2: ResolvedOntologySdkShapeV2;
}
interface ResolvedOutputShape_ontologyDatasource {
    type: "ontologyDatasource";
    ontologyDatasource: ResolvedOntologyDatasourceShape;
}
interface ResolvedOutputShape_peerProducerProfile {
    type: "peerProducerProfile";
    peerProducerProfile: ResolvedPeerProducerProfileShape;
}
interface ResolvedOutputShape_peerProfile {
    type: "peerProfile";
    peerProfile: RidResolvedShape;
}
interface ResolvedOutputShape_property {
    type: "property";
    property: ResolvedPropertyShape;
}
interface ResolvedOutputShape_quiverDashboard {
    type: "quiverDashboard";
    quiverDashboard: ResolvedQuiverDashboardShape;
}
interface ResolvedOutputShape_resourceUpdatesContent {
    type: "resourceUpdatesContent";
    resourceUpdatesContent: RidResolvedShape;
}
interface ResolvedOutputShape_rosettaDocsBundle {
    type: "rosettaDocsBundle";
    rosettaDocsBundle: ResolvedRosettaDocsBundleShape;
}
interface ResolvedOutputShape_savedSearchAroundV2 {
    type: "savedSearchAroundV2";
    savedSearchAroundV2: ResolvedSavedSearchAroundV2OutputShape;
}
interface ResolvedOutputShape_schedule {
    type: "schedule";
    schedule: ResolvedScheduleShape;
}
interface ResolvedOutputShape_sharedPropertyType {
    type: "sharedPropertyType";
    sharedPropertyType: ResolvedSharedPropertyTypeShape;
}
interface ResolvedOutputShape_slateApplication {
    type: "slateApplication";
    slateApplication: RidResolvedShape;
}
interface ResolvedOutputShape_storedProcedure {
    type: "storedProcedure";
    storedProcedure: ResolvedStoredProcedureShape;
}
interface ResolvedOutputShape_solutionDesign {
    type: "solutionDesign";
    solutionDesign: ResolvedSolutionDesignShape;
}
interface ResolvedOutputShape_tabularDatasource {
    type: "tabularDatasource";
    tabularDatasource: ResolvedDatasourceShape;
}
interface ResolvedOutputShape_taurusWorkflow {
    type: "taurusWorkflow";
    taurusWorkflow: RidResolvedShape;
}
interface ResolvedOutputShape_thirdPartyApplication {
    type: "thirdPartyApplication";
    thirdPartyApplication: ResolvedThirdPartyApplicationShape;
}
interface ResolvedOutputShape_timeSeriesSync {
    type: "timeSeriesSync";
    timeSeriesSync: ResolvedTimeSeriesSyncShape;
}
interface ResolvedOutputShape_transformsJobSpec {
    type: "transformsJobSpec";
    transformsJobSpec: RidResolvedShape;
}
interface ResolvedOutputShape_valueType {
    type: "valueType";
    valueType: ResolvedValueTypeShape;
}
interface ResolvedOutputShape_versionedObjectSet {
    type: "versionedObjectSet";
    versionedObjectSet: ResolvedVersionedObjectSetShape;
}
interface ResolvedOutputShape_vertexTemplate {
    type: "vertexTemplate";
    vertexTemplate: ResolvedVertexTemplateShape;
}
interface ResolvedOutputShape_vortexTemplate {
    type: "vortexTemplate";
    vortexTemplate: ResolvedVortexTemplateShape;
}
interface ResolvedOutputShape_walkthrough {
    type: "walkthrough";
    walkthrough: ResolvedWalkthroughShape;
}
interface ResolvedOutputShape_webhook {
    type: "webhook";
    webhook: ResolvedWebhookOutputShape;
}
interface ResolvedOutputShape_widget {
    type: "widget";
    widget: ResolvedWidgetShape;
}
interface ResolvedOutputShape_widgetSet {
    type: "widgetSet";
    widgetSet: ResolvedWidgetSetShape;
}
interface ResolvedOutputShape_workbenchTemplate {
    type: "workbenchTemplate";
    workbenchTemplate: RidResolvedShape;
}
interface ResolvedOutputShape_workflowBuilderGraph {
    type: "workflowBuilderGraph";
    workflowBuilderGraph: RidResolvedShape;
}
interface ResolvedOutputShape_workflowGraph {
    type: "workflowGraph";
    workflowGraph: RidResolvedShape;
}
interface ResolvedOutputShape_sqlWorksheet {
    type: "sqlWorksheet";
    sqlWorksheet: ResolvedSqlWorksheetShape;
}
interface ResolvedOutputShape_workshopApplication {
    type: "workshopApplication";
    workshopApplication: RidResolvedShape;
}
/**
 * Resolved versions of the ``OutputShape``. These contain references to actual entities that should satisfy the
 * (unresolved) output shape. ResolvedOutputShapes usually consist of RID(s), but some contain IDs with
 * significantly higher odds of collisions than a regular RID (example: ResolvedObjectTypeShape.id of type ObjectTypeId).
 */
type ResolvedOutputShape = ResolvedOutputShape_action | ResolvedOutputShape_actionParameter | ResolvedOutputShape_aipAgent | ResolvedOutputShape_appConfigTitanium | ResolvedOutputShape_appConfig | ResolvedOutputShape_artifactsRepository | ResolvedOutputShape_authoringLibrary | ResolvedOutputShape_authoringRepository | ResolvedOutputShape_automation | ResolvedOutputShape_autopilotWorkbench | ResolvedOutputShape_blobsterResource | ResolvedOutputShape_carbonWorkspace | ResolvedOutputShape_checkpointConfig | ResolvedOutputShape_cipherChannel | ResolvedOutputShape_cipherLicense | ResolvedOutputShape_codeWorkspace | ResolvedOutputShape_compassResource | ResolvedOutputShape_contourAnalysis | ResolvedOutputShape_contourRef | ResolvedOutputShape_dataHealthCheck | ResolvedOutputShape_dataHealthCheckGroup | ResolvedOutputShape_datasourceColumn | ResolvedOutputShape_deployedApp | ResolvedOutputShape_eddieEdgePipeline | ResolvedOutputShape_eddiePipeline | ResolvedOutputShape_evaluationSuite | ResolvedOutputShape_filesDatasource | ResolvedOutputShape_function | ResolvedOutputShape_functionConfiguration | ResolvedOutputShape_functionPackageConfiguration | ResolvedOutputShape_geotimeSeriesIntegration | ResolvedOutputShape_interfaceType | ResolvedOutputShape_interfaceLinkType | ResolvedOutputShape_interfacePropertyType | ResolvedOutputShape_interfaceActionTypeConstraint | ResolvedOutputShape_interfaceParameterConstraint | ResolvedOutputShape_linkType | ResolvedOutputShape_logic | ResolvedOutputShape_logicFunction | ResolvedOutputShape_machinery | ResolvedOutputShape_magritteExport | ResolvedOutputShape_magritteExtract | ResolvedOutputShape_magritteSource | ResolvedOutputShape_magritteStreamingExtract | ResolvedOutputShape_modelStudio | ResolvedOutputShape_modelStudioConfig | ResolvedOutputShape_model | ResolvedOutputShape_monitor | ResolvedOutputShape_monitorView | ResolvedOutputShape_mapRendererSet | ResolvedOutputShape_mapRendererSetV2 | ResolvedOutputShape_namedCredential | ResolvedOutputShape_networkEgressPolicy | ResolvedOutputShape_normalizationMaxClassification | ResolvedOutputShape_notepadDocument | ResolvedOutputShape_notepadTemplate | ResolvedOutputShape_notepadTemplateParameter | ResolvedOutputShape_objectSet | ResolvedOutputShape_objectType | ResolvedOutputShape_objectView | ResolvedOutputShape_objectViewTab | ResolvedOutputShape_ontologySdk | ResolvedOutputShape_ontologySdkV2 | ResolvedOutputShape_ontologyDatasource | ResolvedOutputShape_peerProducerProfile | ResolvedOutputShape_peerProfile | ResolvedOutputShape_property | ResolvedOutputShape_quiverDashboard | ResolvedOutputShape_resourceUpdatesContent | ResolvedOutputShape_rosettaDocsBundle | ResolvedOutputShape_savedSearchAroundV2 | ResolvedOutputShape_schedule | ResolvedOutputShape_sharedPropertyType | ResolvedOutputShape_slateApplication | ResolvedOutputShape_storedProcedure | ResolvedOutputShape_solutionDesign | ResolvedOutputShape_tabularDatasource | ResolvedOutputShape_taurusWorkflow | ResolvedOutputShape_thirdPartyApplication | ResolvedOutputShape_timeSeriesSync | ResolvedOutputShape_transformsJobSpec | ResolvedOutputShape_valueType | ResolvedOutputShape_versionedObjectSet | ResolvedOutputShape_vertexTemplate | ResolvedOutputShape_vortexTemplate | ResolvedOutputShape_walkthrough | ResolvedOutputShape_webhook | ResolvedOutputShape_widget | ResolvedOutputShape_widgetSet | ResolvedOutputShape_workbenchTemplate | ResolvedOutputShape_workflowBuilderGraph | ResolvedOutputShape_workflowGraph | ResolvedOutputShape_sqlWorksheet | ResolvedOutputShape_workshopApplication;
/**
 * Attaching the same entity multiple times is not supported.
 */
interface ResolvedOutputShapeAttachedMultipleTimes {
    references: Array<OutputReference>;
}
/**
 * Resolved conterpart of OutputSpec, with version/config specified for resources with a version/config, else
 * explicitly declared empty. Returned from integrations on packaging.
 */
interface ResolvedOutputSpec {
    configuration: ResolvedOutputSpecConfig;
    rid: string;
    version: ResolvedOutputSpecVersion;
}
interface ResolvedOutputSpecAndProvenance {
    outputSpec: ResolvedOutputSpec;
    provenance: Array<OutputSpecProvenance>;
}
interface ResolvedOutputSpecConfig_notConfigurable {
    type: "notConfigurable";
    notConfigurable: Void;
}
interface ResolvedOutputSpecConfig_config {
    type: "config";
    config: OutputSpecConfig;
}
type ResolvedOutputSpecConfig = ResolvedOutputSpecConfig_notConfigurable | ResolvedOutputSpecConfig_config;
interface ResolvedOutputSpecVersion_unversioned {
    type: "unversioned";
    unversioned: Void;
}
interface ResolvedOutputSpecVersion_version {
    type: "version";
    version: ResourceVersion;
}
type ResolvedOutputSpecVersion = ResolvedOutputSpecVersion_unversioned | ResolvedOutputSpecVersion_version;
/**
 * See docs of `OverrideOntologyEntityApiNamesShape` for details. This value is false by default
 */
interface ResolvedOverrideOntologyEntityApiNamesShape {
    enable: boolean;
}
interface ResolvedParameterInputShape {
    value: DataValue;
}
interface ResolvedPeerProducerProfileShape {
    peerProducerProfileRid: PeerProducerProfileRid;
    peerProducerUri: ProducerUri;
    peerProfileRid: PeerProfileRid;
}
interface ResolvedPeerProfileRemoteStrategyShape_specificRemote {
    type: "specificRemote";
    specificRemote: SpecificRemoteStrategy;
}
interface ResolvedPeerProfileRemoteStrategyShape_meshId {
    type: "meshId";
    meshId: MeshIdRemoteStrategy;
}
interface ResolvedPeerProfileRemoteStrategyShape_meshNodeLabel {
    type: "meshNodeLabel";
    meshNodeLabel: MeshNodeLabelRemoteStrategy;
}
type ResolvedPeerProfileRemoteStrategyShape = ResolvedPeerProfileRemoteStrategyShape_specificRemote | ResolvedPeerProfileRemoteStrategyShape_meshId | ResolvedPeerProfileRemoteStrategyShape_meshNodeLabel;
interface ResolvedPresetValue_fromSource {
    type: "fromSource";
    fromSource: FromSourceResolvedPresetValue;
}
interface ResolvedPresetValue_resolvedShapeOverrides {
    type: "resolvedShapeOverrides";
    resolvedShapeOverrides: ResolvedShapeOverridesResolvedPresetValue;
}
type ResolvedPresetValue = ResolvedPresetValue_fromSource | ResolvedPresetValue_resolvedShapeOverrides;
/**
 * The result of resolving a product group member's version policy to a concrete block set version. If the
 * requestor does not have access to the member's source, the resolved version will not be provided.
 */
interface ResolvedProductGroupMember {
    blockSetVersionId?: BlockSetVersionId | null | undefined;
    memberRid: ProductGroupMemberRid;
    source: ProductGroupMemberSpec;
    version?: SemverVersion | null | undefined;
}
interface ResolvedPropertyShape {
    apiName?: ObjectTypeFieldApiName | null | undefined;
    id: PropertyTypeId;
    objectTypeId: ObjectTypeId;
    objectTypeRid: ObjectTypeRid;
    ontologyRid: OntologyRid;
    rid: PropertyTypeRid;
    structFieldRids: Record<ObjectTypeFieldApiName, StructFieldRid>;
}
/**
 * Quiver dashboard resolved shape
 */
interface ResolvedQuiverDashboardShape {
    rid: string;
    version?: number | null | undefined;
}
/**
 * Rosetta documentation bundle, which can only be opened in the Rosetta app (never an input to other blocks).
 */
interface ResolvedRosettaDocsBundleShape {
    bundleId: RosettaProductId;
    securityRid: RosettaDocsBundleSecurityRid;
}
/**
 * Resolved reference to a specific Search Around.
 */
interface ResolvedSavedSearchAroundV2OutputShape {
    rid: string;
}
interface ResolvedScheduleShape {
    scheduleRid: ScheduleRid;
    securityRid: ScheduleSecurityRid;
}
interface ResolvedShapeOverridesResolvedPresetValue {
    resultPerOption: Array<ResolvedShapeResolutionResultUnion>;
}
interface ResolvedShapeResolutionFailure {
    error: MarketplaceSerializableError;
}
interface ResolvedShapeResolutionResultUnion_resolutionSuccess {
    type: "resolutionSuccess";
    resolutionSuccess: ResolvedShapeResolutionSuccess;
}
interface ResolvedShapeResolutionResultUnion_resolutionFailure {
    type: "resolutionFailure";
    resolutionFailure: ResolvedShapeResolutionFailure;
}
type ResolvedShapeResolutionResultUnion = ResolvedShapeResolutionResultUnion_resolutionSuccess | ResolvedShapeResolutionResultUnion_resolutionFailure;
interface ResolvedShapeResolutionSuccess {
    resolvedShape: ResolvedBlockSetInputShape;
}
/**
 * Shape Id that was resolved for the SharedPropertyType does not match the shape id expected.
 */
interface ResolvedSharedPropertyTypeReferenceMismatch {
    actual: SharedPropertyTypeReference;
    expected: SharedPropertyTypeReference;
}
interface ResolvedSharedPropertyTypeShape {
    apiName?: ObjectTypeFieldApiName | null | undefined;
    ontologyRid: OntologyRid;
    rid: SharedPropertyTypeRid;
    structFieldRids: Record<ObjectTypeFieldApiName, StructFieldRid>;
}
/**
 * Solution Design Diagram created by a user and saved in Compass.
 */
interface ResolvedSolutionDesignShape {
    rid: DiagramRid;
}
interface ResolvedSparkProfile {
    name: SparkProfileName;
    rid: SparkProfileRid;
}
interface ResolvedSqlWorksheetShape {
    sqlWorksheetRid: string;
    version: string;
}
interface ResolvedStoredProcedureShape {
    securityRid: string;
    specVersion: string;
    storedProcedureRid: string;
}
interface ResolvedThirdPartyApplicationShape {
    rid: ThirdPartyApplicationRid;
}
interface ResolvedTimeSeriesSyncShape {
    syncRid: TimeSeriesSyncRid;
}
interface ResolvedValueTypeShape {
    valueTypeRid: ValueTypeRid;
    valueTypeVersion: ValueTypeVersion;
    valueTypeVersionId?: ValueTypeVersionId | null | undefined;
}
interface ResolvedVersionedObjectSetShape {
    version: string;
    versionedObjectSetRid: string;
}
/**
 * Vertex template resolved shape. Currently just a rid, open for adding parameters in the future if necessary
 */
interface ResolvedVertexTemplateShape {
    rid: string;
}
/**
 * Vortex template resolved shape. Currently just a rid, open for adding parameters in the future if necessary
 */
interface ResolvedVortexTemplateShape {
    rid: string;
}
interface ResolvedWalkthroughShape {
    rid: string;
}
/**
 * Resolved shape representing a webhook input.
 */
interface ResolvedWebhookInputShape {
    version: WebhookVersion;
    webhookRid: WebhookRid;
}
/**
 * Resolved shape representing a webhook output.
 */
interface ResolvedWebhookOutputShape {
    version: WebhookVersion;
    webhookRid: WebhookRid;
}
interface ResolvedWidgetSetShape {
    widgetSetRid: WidgetSetRid;
    widgetSetVersion: WidgetSetVersion;
}
interface ResolvedWidgetShape {
    widgetRid: WidgetRid;
    widgetSetRid: WidgetSetRid;
    widgetSetVersion: WidgetSetVersion;
}
interface ResolvedWorkshopApplicationSaveLocationInputShape {
    enableCompassLocationSelector: boolean;
    enableHomeFolderSaves: boolean;
    hideInaccessibleLocations: boolean;
    id: StableShapeIdentifier;
    saveLocations: Array<WorkshopApplicationSaveLocation>;
}
/**
 * Resolves a version for a given member source.
 */
interface ResolveMemberSourceRequest {
    memberSource: ProductGroupMemberSpec;
}
interface ResolveMemberSourceResponse {
    blockSetId: BlockSetId;
    blockSetVersionId: BlockSetVersionId;
    marketplaceRid: MarketplaceRid;
    memberSource: ProductGroupMemberSpec;
    version?: SemverVersion | null | undefined;
}
interface ResolvePresetsRequest {
    targetInstallLocation: ResolvePresetsTargetInstallLocation;
}
interface ResolvePresetsResponse {
    resolvedPresets: Record<InputBlockSetShapeId, InputPresetResolutionResult>;
}
interface ResolvePresetsTargetInstallLocation {
    compassFolderRid?: CompassFolderRid | null | undefined;
    ontologyRid?: OntologyRid | null | undefined;
}
interface ResourceInstallationProvenanceResponse {
    blockSetInstallationRid: BlockSetInstallationRid;
    blockSetShapeId?: BlockSetShapeId | null | undefined;
}
/**
 * The provided RID is not a project (e.g., it is a folder).
 */
interface ResourceIsNotProject {
    resourceRid: CompassFolderRid;
}
interface ResourcePermissionDenied {
    rid: string;
}
/**
 * Represents the resource type of an rid
 */
type ResourceType = string;
/**
 * This represents a ResourceUpdates contentRid
 */
interface ResourceUpdatesContentIdentifier {
    rid: string;
}
/**
 * Resource Updates refer to the generic concept that represents Product Walkthroughs.
 * This shape represents the Content of each slide in a Product Walkthrough.
 * We use this output shape to be able to preallocate ContentRids of a ResourceUpdate and keep it consistent
 * across installations.
 */
interface ResourceUpdatesContentOutputShape {
    about: LocalizedTitleAndDescription;
}
interface ResourceUpdatesCreateBlockRequest {
    resourceRid: string;
}
interface ResourceUsedAsBothInputAndOutput {
    inputs: Array<ResolvedInputShape>;
    outputs: Array<ResolvedOutputShape>;
}
interface ResourceVersion_integer {
    type: "integer";
    integer: IntegerVersion;
}
interface ResourceVersion_long {
    type: "long";
    long: LongVersion;
}
interface ResourceVersion_rid {
    type: "rid";
    rid: RidVersion;
}
interface ResourceVersion_semver {
    type: "semver";
    semver: SemverVersion;
}
interface ResourceVersion_string {
    type: "string";
    string: StringVersion;
}
interface ResourceVersion_uuid {
    type: "uuid";
    uuid: UuidVersion;
}
/**
 * Generic version type for Foundry resources - can be applied to shape versions and output spec versions.
 * Used for output specs during packaging, for shape version merging, for version skew validation errors, etc.,.
 */
type ResourceVersion = ResourceVersion_integer | ResourceVersion_long | ResourceVersion_rid | ResourceVersion_semver | ResourceVersion_string | ResourceVersion_uuid;
/**
 * Corresponds 1:1 with the member types of the ResourceVersion union.
 */
type ResourceVersionType = "INTEGER" | "LONG" | "RID" | "SEMVER" | "STRING" | "UUID";
interface RestrictedViewCreateBlockRequest {
    rid: string;
}
interface RestrictedViewLocator {
    rid: string;
}
interface RestrictedViewLocatorIdentifier {
    rid: string;
}
/**
 * A RID with * as a wildcard.
 * Wildcards can only replace entire components, so `ri.service.main.*.*` is legal but `ri.service.main.ty*.*` is
 * not.
 *
 * Supports exact match RIDs e.g., "ri.marketplace.main.local.00000000-0000-0000-0000-000000000001" or
 * patterns where any of the components of service, main, type or UUID are replaced by a "*", for example
 * "ri.marketplace.*.*.*".
 */
type RidFilter = string;
interface RidResolvedShape {
    rid: string;
}
interface RidShapeIdentifier {
    rid: string;
}
type RidVersion = string;
/**
 * A role to be granted to a principal during an installation.
 */
interface RoleGrant {
    principal: Principal;
    role: RoleId;
}
type RoleId = string;
type RoleSetId = string;
/**
 * Will roll forward to the latest version that can be auto-upgraded to
 */
interface RollForwardStrategy {
}
interface RollOffStrategy_rollForward {
    type: "rollForward";
    rollForward: RollForwardStrategy;
}
/**
 * Specifies how installations of the recalled version should be rolled off
 */
type RollOffStrategy = RollOffStrategy_rollForward;
interface RosettaCreateBlockRequest {
    productId: string;
}
/**
 * A single Rosetta documentation bundle exists for a product. Thus, we identify a documentation bundle using
 * the product's identifier.
 */
interface RosettaDocsBundleIdentifier {
    productId: RosettaProductId;
    securityRid: RosettaDocsBundleSecurityRid;
}
type RosettaDocsBundleSecurityRid = string;
/**
 * Rosetta documentation bundle, which can only be opened in the Rosetta app (never an input to other blocks).
 */
interface RosettaDocsBundleShape {
    about: LocalizedTitleAndDescription;
}
type RosettaProductId = string;
interface RtfFormat {
}
interface SatelliteImageryModelCreateBlockRequest {
    modelRid: string;
    modelVersionRid: string;
}
interface SavedSearchAroundV2CreateBlockRequest {
    rid: string;
}
interface SavedSearchAroundV2OutputIdentifier {
    rid: string;
}
/**
 * An Advanced Search Around (Search Around V2) - a saved, versioned
 * graph-traversal query over the Foundry Ontology.
 */
interface SavedSearchAroundV2OutputShape {
    about: LocalizedTitleAndDescription;
}
/**
 * A parameter type of ScenarioReferenceType.
 */
interface ScenarioReferenceType {
}
interface ScheduleCreateBlockRequest {
    scheduleRid: string;
    scheduleVersionRid?: string | null | undefined;
}
interface ScheduleIdentifier {
    scheduleRid: ScheduleRid;
}
/**
 * Rid of the schedule. This is consistent across schedule versions.
 */
type ScheduleRid = string;
/**
 * Rid of the schedule version.
 */
type ScheduleSecurityRid = string;
interface ScheduleShape {
    about: LocalizedTitleAndDescription;
}
interface ScheduleShapeInvalid_scheduleVersionInvalid {
    type: "scheduleVersionInvalid";
    scheduleVersionInvalid: ScheduleVersionInvalid;
}
type ScheduleShapeInvalid = ScheduleShapeInvalid_scheduleVersionInvalid;
/**
 * Schedule version is not found for the scheduleRid given.
 */
interface ScheduleVersionInvalid {
    scheduleRid: ScheduleRid;
    scheduleSecurityRid: ScheduleSecurityRid;
}
/**
 * A single key in a multi-key secret (e.g. user-defined multi-key secrets in Apollo). Can be used for secrets
 * with the same shape in other systems.
 */
type SecretKey = string;
type SecretName = string;
interface SemverVersion {
    major: SemverVersionComponent;
    minor: SemverVersionComponent;
    patch: SemverVersionComponent;
}
type SemverVersionComponent = number;
/**
 * A type that can be converted directly from a Conjure `ServiceException`.
 * If a single error is encountered in an integration it should be thrown. If multiple errors need to be
 * collected, they can be returned using this `SerializableError` type.
 * To construct the error, you must use the `Exceptions.toSerializableError()` util to ensure safe JSON parameter
 * serialization.
 */
interface SerializableCreateBlockVersionError {
    error: MarketplaceSerializableError;
}
interface SerializedDataLocator_conda {
    type: "conda";
    conda: CondaLocator;
}
interface SerializedDataLocator_condaV2 {
    type: "condaV2";
    condaV2: CondaLocatorV2;
}
interface SerializedDataLocator_files {
    type: "files";
    files: FilesLocator;
}
interface SerializedDataLocator_maven {
    type: "maven";
    maven: MavenLocator;
}
interface SerializedDataLocator_npm {
    type: "npm";
    npm: NpmLocator;
}
interface SerializedDataLocator_oci {
    type: "oci";
    oci: OciLocator;
}
interface SerializedDataLocator_pypi {
    type: "pypi";
    pypi: PypiLocator;
}
interface SerializedDataLocator_repoData {
    type: "repoData";
    repoData: RepoDataLocator;
}
/**
 * A locator to a piece of serialized data.
 * These correspond to (a subset of) foundry artifacts layouts.
 */
type SerializedDataLocator = SerializedDataLocator_conda | SerializedDataLocator_condaV2 | SerializedDataLocator_files | SerializedDataLocator_maven | SerializedDataLocator_npm | SerializedDataLocator_oci | SerializedDataLocator_pypi | SerializedDataLocator_repoData;
/**
 * A versioned cross stack identifier for a service managed value type.
 */
interface ServiceManagedValueTypeIdentifier {
    apiName: ValueTypeApiName;
    version: ValueTypeVersion;
}
/**
 * Represents the service name part of an rid
 */
type ServiceName = string;
interface SetBlockSetInstallationImmutabilityRequest {
    immutability: BlockSetInstallationImmutability;
    rolesMap: Record<RoleId, Array<RoleId>>;
}
interface SetBlockSetInstallationImmutabilityResponse {
}
interface SetInputPresetRequest {
    enforcement?: PresetEnforcement | null | undefined;
    isDefault?: boolean | null | undefined;
    value: SetInputPresetValueRequest;
}
interface SetInputPresetValueRequest_fromSource {
    type: "fromSource";
    fromSource: SetPresetFromSourceRequest;
}
interface SetInputPresetValueRequest_resolvedShapeOverrides {
    type: "resolvedShapeOverrides";
    resolvedShapeOverrides: SetPresetResolvedShapesOverridesRequest;
}
type SetInputPresetValueRequest = SetInputPresetValueRequest_fromSource | SetInputPresetValueRequest_resolvedShapeOverrides;
interface SetInstallAutomationSettingsRequest {
    settings: InstallAutomationSettings;
}
interface SetManagedStoreSettingsForOrgRequest {
    settings: Record<MarketplaceRid, ManagedStoreConfiguredSettingsEntry>;
}
interface SetManagedStoreSettingsForOrgResponse {
    marketplaceRids: Array<MarketplaceRid>;
}
interface SetMarketplaceMavenGroupRequest {
    mavenGroup: MavenGroup;
}
interface SetMarketplaceMavenGroupResponse {
}
interface SetPresetFromSourceRequest {
}
interface SetPresetResolvedShapesOverridesRequest {
    defaultIndex?: number | null | undefined;
    resolvedShapes: Array<ResolvedBlockSetInputShape>;
}
interface SetProjectImmutabilityRequest {
    immutability: BlockSetInstallationImmutability;
    projectRid: CompassProjectRid;
    rolesMap: Record<RoleId, Array<RoleId>>;
}
interface SetProjectImmutabilityResponse {
}
interface SetProjectMutabilityAllowance_allowed {
    type: "allowed";
    allowed: Void;
}
interface SetProjectMutabilityAllowance_disallowed {
    type: "disallowed";
    disallowed: SetProjectMutabilityDisallowedRationale;
}
type SetProjectMutabilityAllowance = SetProjectMutabilityAllowance_allowed | SetProjectMutabilityAllowance_disallowed;
interface SetProjectMutabilityDisallowedRationale_permissionDenied {
    type: "permissionDenied";
    permissionDenied: SetProjectMutabilityPermissionDenied;
}
interface SetProjectMutabilityDisallowedRationale_resourceIsNotProject {
    type: "resourceIsNotProject";
    resourceIsNotProject: ResourceIsNotProject;
}
/**
 * Rationale for why project mutability cannot be changed.
 */
type SetProjectMutabilityDisallowedRationale = SetProjectMutabilityDisallowedRationale_permissionDenied | SetProjectMutabilityDisallowedRationale_resourceIsNotProject;
/**
 * The user does not have permission to change the project's mutability.
 */
interface SetProjectMutabilityPermissionDenied {
    projectRid: CompassProjectRid;
}
interface SetReleaseChannelsForBlockSetVersionRequest {
    channels: Array<ReleaseChannel>;
}
/**
 * Declarative specification of the desired input mappings and output shapes for a single installation
 * within a draft. Replaces the existing mappings entirely. Optional overrides can be provided to
 * selectively modify other installation properties.
 */
interface SetTargetInstallation {
    installationRid: BlockSetInstallationRid;
    overrides?: TargetInstallationOverrides | null | undefined;
    resolvedOutputShapesToAttach: Record<OutputBlockSetShapeId, ResolvedBlockSetOutputShape>;
    targetInputShapes: Record<InputBlockSetShapeId, TargetInputShape>;
}
interface SetTargetInstallLocation {
    ontology?: OntologyInstallLocation | null | undefined;
}
type Sha256Hash = string;
interface ShapeDisplayMetadata_simple {
    type: "simple";
    simple: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_action {
    type: "action";
    action: ActionTypeShapeDisplayMetadata;
}
interface ShapeDisplayMetadata_actionParameter {
    type: "actionParameter";
    actionParameter: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_allowOntologySchemaMigrations {
    type: "allowOntologySchemaMigrations";
    allowOntologySchemaMigrations: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_appConfigTitanium {
    type: "appConfigTitanium";
    appConfigTitanium: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_artifactsRepository {
    type: "artifactsRepository";
    artifactsRepository: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_authoringLibrary {
    type: "authoringLibrary";
    authoringLibrary: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_authoringRepository {
    type: "authoringRepository";
    authoringRepository: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_automation {
    type: "automation";
    automation: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_autopilotWorkbench {
    type: "autopilotWorkbench";
    autopilotWorkbench: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_blobsterResource {
    type: "blobsterResource";
    blobsterResource: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_carbonWorkspace {
    type: "carbonWorkspace";
    carbonWorkspace: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_checkpointConfig {
    type: "checkpointConfig";
    checkpointConfig: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_cipherChannel {
    type: "cipherChannel";
    cipherChannel: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_cipherLicense {
    type: "cipherLicense";
    cipherLicense: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_cipherLicenseV2 {
    type: "cipherLicenseV2";
    cipherLicenseV2: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_codeWorkspace {
    type: "codeWorkspace";
    codeWorkspace: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_codeWorkspaceLicense {
    type: "codeWorkspaceLicense";
    codeWorkspaceLicense: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_compassResource {
    type: "compassResource";
    compassResource: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_contourAnalysis {
    type: "contourAnalysis";
    contourAnalysis: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_contourRef {
    type: "contourRef";
    contourRef: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_dataHealthCheck {
    type: "dataHealthCheck";
    dataHealthCheck: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_dataHealthCheckGroup {
    type: "dataHealthCheckGroup";
    dataHealthCheckGroup: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_datasourceColumn {
    type: "datasourceColumn";
    datasourceColumn: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_deployedApp {
    type: "deployedApp";
    deployedApp: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_eddieEdgePipeline {
    type: "eddieEdgePipeline";
    eddieEdgePipeline: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_eddieParameter {
    type: "eddieParameter";
    eddieParameter: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_eddieParameterV2 {
    type: "eddieParameterV2";
    eddieParameterV2: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_eddieReplayOption {
    type: "eddieReplayOption";
    eddieReplayOption: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_eddiePipeline {
    type: "eddiePipeline";
    eddiePipeline: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_eddieGeotimeConfiguration {
    type: "eddieGeotimeConfiguration";
    eddieGeotimeConfiguration: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_edgePipelineMagritteSource {
    type: "edgePipelineMagritteSource";
    edgePipelineMagritteSource: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_evaluationSuite {
    type: "evaluationSuite";
    evaluationSuite: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_filesDatasource {
    type: "filesDatasource";
    filesDatasource: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_flinkProfile {
    type: "flinkProfile";
    flinkProfile: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_function {
    type: "function";
    function: FunctionShapeDisplayMetadata;
}
interface ShapeDisplayMetadata_functionConfiguration {
    type: "functionConfiguration";
    functionConfiguration: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_functionPackageConfiguration {
    type: "functionPackageConfiguration";
    functionPackageConfiguration: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_fusionDocument {
    type: "fusionDocument";
    fusionDocument: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_geotimeSeriesIntegration {
    type: "geotimeSeriesIntegration";
    geotimeSeriesIntegration: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_installPrefix {
    type: "installPrefix";
    installPrefix: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_interfaceType {
    type: "interfaceType";
    interfaceType: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_interfaceLinkType {
    type: "interfaceLinkType";
    interfaceLinkType: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_interfacePropertyType {
    type: "interfacePropertyType";
    interfacePropertyType: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_interfaceActionTypeConstraint {
    type: "interfaceActionTypeConstraint";
    interfaceActionTypeConstraint: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_interfaceParameterConstraint {
    type: "interfaceParameterConstraint";
    interfaceParameterConstraint: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_languageModel {
    type: "languageModel";
    languageModel: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_linkType {
    type: "linkType";
    linkType: LinkTypeShapeDisplayMetadata;
}
interface ShapeDisplayMetadata_logic {
    type: "logic";
    logic: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_logicFunction {
    type: "logicFunction";
    logicFunction: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_machinery {
    type: "machinery";
    machinery: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_magritteConnection {
    type: "magritteConnection";
    magritteConnection: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_magritteExport {
    type: "magritteExport";
    magritteExport: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_magritteExtract {
    type: "magritteExtract";
    magritteExtract: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_magritteSource {
    type: "magritteSource";
    magritteSource: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_magritteStreamingExtract {
    type: "magritteStreamingExtract";
    magritteStreamingExtract: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_markings {
    type: "markings";
    markings: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_modelStudio {
    type: "modelStudio";
    modelStudio: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_modelStudioConfig {
    type: "modelStudioConfig";
    modelStudioConfig: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_model {
    type: "model";
    model: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_monocleGraph {
    type: "monocleGraph";
    monocleGraph: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_multipassUserAttribute {
    type: "multipassUserAttribute";
    multipassUserAttribute: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_multipassGroup {
    type: "multipassGroup";
    multipassGroup: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_namedCredential {
    type: "namedCredential";
    namedCredential: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_networkEgressPolicy {
    type: "networkEgressPolicy";
    networkEgressPolicy: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_notepadDocument {
    type: "notepadDocument";
    notepadDocument: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_notepadTemplate {
    type: "notepadTemplate";
    notepadTemplate: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_notepadTemplateParameter {
    type: "notepadTemplateParameter";
    notepadTemplateParameter: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_objectInstance {
    type: "objectInstance";
    objectInstance: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_objectSet {
    type: "objectSet";
    objectSet: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_objectType {
    type: "objectType";
    objectType: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_objectView {
    type: "objectView";
    objectView: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_objectViewTab {
    type: "objectViewTab";
    objectViewTab: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_ontologyDatasource {
    type: "ontologyDatasource";
    ontologyDatasource: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_parameter {
    type: "parameter";
    parameter: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_property {
    type: "property";
    property: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_quiverDashboard {
    type: "quiverDashboard";
    quiverDashboard: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_resourceUpdatesContent {
    type: "resourceUpdatesContent";
    resourceUpdatesContent: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_rosettaDocsBundle {
    type: "rosettaDocsBundle";
    rosettaDocsBundle: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_schedule {
    type: "schedule";
    schedule: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_sharedPropertyType {
    type: "sharedPropertyType";
    sharedPropertyType: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_ontologySdk {
    type: "ontologySdk";
    ontologySdk: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_ontologySdkV2 {
    type: "ontologySdkV2";
    ontologySdkV2: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_slateApplication {
    type: "slateApplication";
    slateApplication: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_solutionDesign {
    type: "solutionDesign";
    solutionDesign: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_storedProcedure {
    type: "storedProcedure";
    storedProcedure: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_sparkProfile {
    type: "sparkProfile";
    sparkProfile: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_tabularDatasource {
    type: "tabularDatasource";
    tabularDatasource: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_taurusWorkflow {
    type: "taurusWorkflow";
    taurusWorkflow: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_thirdPartyApplication {
    type: "thirdPartyApplication";
    thirdPartyApplication: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_timeSeriesSync {
    type: "timeSeriesSync";
    timeSeriesSync: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_transformsJobSpec {
    type: "transformsJobSpec";
    transformsJobSpec: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_valueType {
    type: "valueType";
    valueType: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_vectorWorkbook {
    type: "vectorWorkbook";
    vectorWorkbook: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_versionedObjectSet {
    type: "versionedObjectSet";
    versionedObjectSet: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_vertexTemplate {
    type: "vertexTemplate";
    vertexTemplate: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_vortexTemplate {
    type: "vortexTemplate";
    vortexTemplate: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_walkthrough {
    type: "walkthrough";
    walkthrough: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_webhook {
    type: "webhook";
    webhook: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_workbenchTemplate {
    type: "workbenchTemplate";
    workbenchTemplate: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_workflowGraph {
    type: "workflowGraph";
    workflowGraph: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_sqlWorksheet {
    type: "sqlWorksheet";
    sqlWorksheet: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_workshopApplication {
    type: "workshopApplication";
    workshopApplication: SimpleDisplayMetadata;
}
interface ShapeDisplayMetadata_workshopApplicationSaveLocation {
    type: "workshopApplicationSaveLocation";
    workshopApplicationSaveLocation: SimpleDisplayMetadata;
}
/**
 * Display metadata, such as title and description, for a shape. Most shapes use the `SimpleDisplayMetadata`
 * type, but more complex shape types that include multiple `about` fields use their own types.
 *
 * This union should contain one entry per shape type.
 */
type ShapeDisplayMetadata = ShapeDisplayMetadata_simple | ShapeDisplayMetadata_action | ShapeDisplayMetadata_actionParameter | ShapeDisplayMetadata_allowOntologySchemaMigrations | ShapeDisplayMetadata_appConfigTitanium | ShapeDisplayMetadata_artifactsRepository | ShapeDisplayMetadata_authoringLibrary | ShapeDisplayMetadata_authoringRepository | ShapeDisplayMetadata_automation | ShapeDisplayMetadata_autopilotWorkbench | ShapeDisplayMetadata_blobsterResource | ShapeDisplayMetadata_carbonWorkspace | ShapeDisplayMetadata_checkpointConfig | ShapeDisplayMetadata_cipherChannel | ShapeDisplayMetadata_cipherLicense | ShapeDisplayMetadata_cipherLicenseV2 | ShapeDisplayMetadata_codeWorkspace | ShapeDisplayMetadata_codeWorkspaceLicense | ShapeDisplayMetadata_compassResource | ShapeDisplayMetadata_contourAnalysis | ShapeDisplayMetadata_contourRef | ShapeDisplayMetadata_dataHealthCheck | ShapeDisplayMetadata_dataHealthCheckGroup | ShapeDisplayMetadata_datasourceColumn | ShapeDisplayMetadata_deployedApp | ShapeDisplayMetadata_eddieEdgePipeline | ShapeDisplayMetadata_eddieParameter | ShapeDisplayMetadata_eddieParameterV2 | ShapeDisplayMetadata_eddieReplayOption | ShapeDisplayMetadata_eddiePipeline | ShapeDisplayMetadata_eddieGeotimeConfiguration | ShapeDisplayMetadata_edgePipelineMagritteSource | ShapeDisplayMetadata_evaluationSuite | ShapeDisplayMetadata_filesDatasource | ShapeDisplayMetadata_flinkProfile | ShapeDisplayMetadata_function | ShapeDisplayMetadata_functionConfiguration | ShapeDisplayMetadata_functionPackageConfiguration | ShapeDisplayMetadata_fusionDocument | ShapeDisplayMetadata_geotimeSeriesIntegration | ShapeDisplayMetadata_installPrefix | ShapeDisplayMetadata_interfaceType | ShapeDisplayMetadata_interfaceLinkType | ShapeDisplayMetadata_interfacePropertyType | ShapeDisplayMetadata_interfaceActionTypeConstraint | ShapeDisplayMetadata_interfaceParameterConstraint | ShapeDisplayMetadata_languageModel | ShapeDisplayMetadata_linkType | ShapeDisplayMetadata_logic | ShapeDisplayMetadata_logicFunction | ShapeDisplayMetadata_machinery | ShapeDisplayMetadata_magritteConnection | ShapeDisplayMetadata_magritteExport | ShapeDisplayMetadata_magritteExtract | ShapeDisplayMetadata_magritteSource | ShapeDisplayMetadata_magritteStreamingExtract | ShapeDisplayMetadata_markings | ShapeDisplayMetadata_modelStudio | ShapeDisplayMetadata_modelStudioConfig | ShapeDisplayMetadata_model | ShapeDisplayMetadata_monocleGraph | ShapeDisplayMetadata_multipassUserAttribute | ShapeDisplayMetadata_multipassGroup | ShapeDisplayMetadata_namedCredential | ShapeDisplayMetadata_networkEgressPolicy | ShapeDisplayMetadata_notepadDocument | ShapeDisplayMetadata_notepadTemplate | ShapeDisplayMetadata_notepadTemplateParameter | ShapeDisplayMetadata_objectInstance | ShapeDisplayMetadata_objectSet | ShapeDisplayMetadata_objectType | ShapeDisplayMetadata_objectView | ShapeDisplayMetadata_objectViewTab | ShapeDisplayMetadata_ontologyDatasource | ShapeDisplayMetadata_parameter | ShapeDisplayMetadata_property | ShapeDisplayMetadata_quiverDashboard | ShapeDisplayMetadata_resourceUpdatesContent | ShapeDisplayMetadata_rosettaDocsBundle | ShapeDisplayMetadata_schedule | ShapeDisplayMetadata_sharedPropertyType | ShapeDisplayMetadata_ontologySdk | ShapeDisplayMetadata_ontologySdkV2 | ShapeDisplayMetadata_slateApplication | ShapeDisplayMetadata_solutionDesign | ShapeDisplayMetadata_storedProcedure | ShapeDisplayMetadata_sparkProfile | ShapeDisplayMetadata_tabularDatasource | ShapeDisplayMetadata_taurusWorkflow | ShapeDisplayMetadata_thirdPartyApplication | ShapeDisplayMetadata_timeSeriesSync | ShapeDisplayMetadata_transformsJobSpec | ShapeDisplayMetadata_valueType | ShapeDisplayMetadata_vectorWorkbook | ShapeDisplayMetadata_versionedObjectSet | ShapeDisplayMetadata_vertexTemplate | ShapeDisplayMetadata_vortexTemplate | ShapeDisplayMetadata_walkthrough | ShapeDisplayMetadata_webhook | ShapeDisplayMetadata_workbenchTemplate | ShapeDisplayMetadata_workflowGraph | ShapeDisplayMetadata_sqlWorksheet | ShapeDisplayMetadata_workshopApplication | ShapeDisplayMetadata_workshopApplicationSaveLocation;
interface ShapeDoesNotExistOnBlock {
    blockVersionId: BlockVersionId;
    expectedShape: BlockShapeId;
}
/**
 * Builds which must complete as part of the installation. For example, when downstream shapes depend on the
 * built dataset.
 */
interface ShapeInstallationStatusBuilding {
    builds: Array<InstallationBuild>;
    shapeIds: Array<OutputBlockSetShapeId>;
}
interface ShapeInstallationStatuses {
    building: ShapeInstallationStatusBuilding;
    failed: ShapeInstallationStatusFailed;
    finished: ShapeInstallationStatusFinished;
    notStarted: ShapeInstallationStatusNotStarted;
    pendingBuild: ShapeInstallationStatusPendingBuild;
    preallocating: ShapeInstallationStatusPreallocating;
    reconciling: ShapeInstallationStatusReconciling;
    waitingForIndexing: ShapeInstallationStatusWaitingForIndexing;
}
interface ShapeInstallationStatusFailed {
    builds: Array<InstallationBuild>;
    shapeGroupErrors: Array<BlockInstallationFailure>;
    shapeGroupErrorsV2: Array<BlockInstallationFailureV2>;
}
/**
 * The shapes have been installed.
 */
interface ShapeInstallationStatusFinished {
    builds: Array<InstallationBuild>;
    indexableEntityRids: Record<OutputBlockSetShapeId, IndexableEntityRid>;
    shapeIds: Array<OutputBlockSetShapeId>;
}
interface ShapeInstallationStatusNotStarted {
    shapeIds: Array<OutputBlockSetShapeId>;
}
/**
 * Shapes which are due to build, when building is necessary for the installation to proceed.
 * See `ShapeInstallationStatusBuilding`.
 */
interface ShapeInstallationStatusPendingBuild {
    shapeIds: Array<OutputBlockSetShapeId>;
}
interface ShapeInstallationStatusPreallocating {
    shapeIds: Array<OutputBlockSetShapeId>;
}
interface ShapeInstallationStatusReconciling {
    shapeIds: Array<OutputBlockSetShapeId>;
}
/**
 * Indexes of object types into the ontology which must complete as part of the installation.
 */
interface ShapeInstallationStatusWaitingForIndexing {
    indexableEntityRids: Record<OutputBlockSetShapeId, IndexableEntityRid>;
    shapeIds: Array<OutputBlockSetShapeId>;
}
/**
 * The mapping information of one block shape.
 */
interface ShapeMappingInfo {
    actionParameterMappingInfo?: ActionParameterV1MappingInfo | null | undefined;
    blockSetShapeId: BlockSetShapeId;
    shape: BlockShape;
}
interface ShapeReference {
    blockInstance: BlockSetBlockInstanceId;
    shapeId: BlockShapeId;
}
interface ShapesAffectedByMarkings_datasource {
    type: "datasource";
    datasource: DatasourceLocator;
}
interface ShapesAffectedByMarkings_propertyType {
    type: "propertyType";
    propertyType: PropertyTypeRid;
}
interface ShapesAffectedByMarkings_thirdPartyApplication {
    type: "thirdPartyApplication";
    thirdPartyApplication: ThirdPartyApplicationRid;
}
type ShapesAffectedByMarkings = ShapesAffectedByMarkings_datasource | ShapesAffectedByMarkings_propertyType | ShapesAffectedByMarkings_thirdPartyApplication;
interface ShapesRemovalError {
    error?: MarketplaceSerializableError | null | undefined;
    errorMessage: string;
}
interface SharedPropertyTypeIdentifier_rid {
    type: "rid";
    rid: SharedPropertyTypeRid;
}
type SharedPropertyTypeIdentifier = SharedPropertyTypeIdentifier_rid;
interface SharedPropertyTypeInputShape {
    about: LocalizedTitleAndDescription;
    type: AllowedObjectPropertyType;
}
/**
 * The property has no associated SharedPropertyType whereas the shape definition requires one.
 */
interface SharedPropertyTypeMissing {
    expected: SharedPropertyTypeReference;
}
interface SharedPropertyTypeNotFound {
    sharedPropertyTypeRid?: SharedPropertyTypeRid | null | undefined;
}
interface SharedPropertyTypeOutputShape {
    about: LocalizedTitleAndDescription;
    type: ObjectPropertyType;
}
type SharedPropertyTypeReference = BlockInternalId;
/**
 * An SharedPropertyTypeRid was referenced for which the shape id could not be resolved. This is typical if the
 * referenced SharedPropertyTypeRid has not been included as an input/output in the block.
 */
interface SharedPropertyTypeReferenceUnresolvable {
    actual: SharedPropertyTypeRid;
    expected: SharedPropertyTypeReference;
}
type SharedPropertyTypeRid = string;
/**
 * Copy of com.palantir.intoto.dsse.Signature
 */
interface Signature {
    keyId: string;
    signature: string;
}
/**
 * A hash of a public key from SigningConfig KeyPair, see `com.palantir.marketplace.conf.SigningConfig.keyId`. Observed examples are 64-char long, but it may not not always the case.
 */
type SigningKeyId = string;
type SigningPublicKey = string;
/**
 * DEPRECATED: Replaced by block set shapes internal recommendations.
 * Recommends that an `inputShape`'s input shape is fulfilled by `fulfilledBy`'s output shape.
 */
interface SimpleBlockSetRecommendation {
    fulfilledBy: RecommendationBlockSetReference;
    inputShape: RecommendationBlockSetReference;
}
/**
 * For use in the `ShapeDisplayMetadata` union. Use this type if your shape only includes a single `about` field
 * and no other display metadata.
 */
interface SimpleDisplayMetadata {
    about: LocalizedTitleAndDescription;
}
/**
 * Recommends that an `inputShape`'s input shape is fulfilled by `fulfilledBy`'s output shape.
 */
interface SimpleRecommendation {
    fulfilledBy: RecommendationBlockReference;
    inputShape: RecommendationBlockReference;
}
interface SingleOutputType {
    about: LocalizedTitleAndDescription;
    dataType: DataType$1;
}
interface SingleOutputTypeDisplayMetadata {
    about: LocalizedTitleAndDescription;
}
/**
 * An mp4 container which contains a single audio stream.
 */
interface SingleStreamMp4AudioContainerFormat {
}
/**
 * An ogg container which contains a single audio stream.
 */
interface SingleStreamOggAudioContainerFormat {
    oggAudioFormat: OggAudioFormat;
}
/**
 * A webm container which contains a single audio stream.
 */
interface SingleStreamWebmAudioContainerFormat {
}
interface SingleVersionBlockReference {
    blockId: BlockId;
    blockVersionId: BlockVersionId;
}
interface SlateApplicationIdentifier_rid {
    type: "rid";
    rid: string;
}
type SlateApplicationIdentifier = SlateApplicationIdentifier_rid;
interface SlateApplicationInputShape {
    about: LocalizedTitleAndDescription;
}
interface SlateApplicationOutputShape {
    about: LocalizedTitleAndDescription;
}
interface SlateCreateBlockRequest {
    rid: string;
    version?: number | null | undefined;
}
/**
 * An sls version, such as "1.2.0". Used when dealing with maven coordinates sls resources.
 */
type SlsVersion = string;
/**
 * A point-in-time resolved version for a product group member, captured when the snapshot was created.
 * Unlike ResolvedProductGroupMember, all fields are always populated because the snapshot stores the
 * concrete resolved state rather than applying read-time permission filtering.
 */
interface SnapshotMemberVersion {
    blockSetVersionId: BlockSetVersionId;
    memberRid: ProductGroupMemberRid;
    source: ProductGroupMemberSpec;
    version?: SemverVersion | null | undefined;
}
/**
 * Resource is temporarily disabled/paused.
 * Applied to resources that cannot be soft deleted using other modes.
 */
interface SoftDeleteDisable {
}
interface SoftDeleteMode_trash {
    type: "trash";
    trash: SoftDeleteTrash;
}
interface SoftDeleteMode_skip {
    type: "skip";
    skip: SoftDeleteSkip;
}
interface SoftDeleteMode_disable {
    type: "disable";
    disable: SoftDeleteDisable;
}
/**
 * Mode that will be used to soft delete this resource.
 * Currently used during clean up of unused output shapes (see `CleanupUnusedShapesSettings` for details)
 */
type SoftDeleteMode = SoftDeleteMode_trash | SoftDeleteMode_skip | SoftDeleteMode_disable;
/**
 * No action taken, and is considered the correct long-term behaviour.
 * Applied to immutable or versioned resources that do not create any conflict while existing and
 * are generally expected by downstream consumers to never get deleted.
 */
interface SoftDeleteSkip {
}
/**
 * Resource is trashed and can be restored with its full state.
 * Used for resources that use Compass trashing.
 */
interface SoftDeleteTrash {
}
interface SoftDeleteUninstallOptions {
}
interface SolutionDesignCreateBlockRequest {
    diagramVersion?: number | null | undefined;
    rid: string;
}
/**
 * Solution Design Diagram created by a user and saved in Compass.
 */
interface SolutionDesignIdentifier {
    rid: DiagramRid;
}
/**
 * Solution Design Diagram created by a user and saved in Compass.
 */
interface SolutionDesignShape {
    about: LocalizedTitleAndDescription;
}
interface SparkProfileConstraint_allowedProfileNames {
    type: "allowedProfileNames";
    allowedProfileNames: AllowedProfileNamesConstraint;
}
interface SparkProfileConstraint_profileFamily {
    type: "profileFamily";
    profileFamily: ProfileFamilyConstraint;
}
type SparkProfileConstraint = SparkProfileConstraint_allowedProfileNames | SparkProfileConstraint_profileFamily;
/**
 * The spark profiles selected do not match the constraints of the input shape.
 */
interface SparkProfileConstraintViolated {
    actual: SparkProfileName;
    expected: Array<SparkProfileName>;
}
/**
 * The selected spark profile does not belong to the expected profile family.
 */
interface SparkProfileFamilyMismatch {
    actualFamily: SparkProfileFamilyName;
    expectedFamily: SparkProfileFamilyName;
    profile: SparkProfileName;
}
type SparkProfileFamilyName = string;
interface SparkProfileIdentifier_rid {
    type: "rid";
    rid: SparkProfileRid;
}
interface SparkProfileIdentifier_name {
    type: "name";
    name: SparkProfileName;
}
interface SparkProfileIdentifier_nameConstrained {
    type: "nameConstrained";
    nameConstrained: SparkProfileNameConstrained;
}
type SparkProfileIdentifier = SparkProfileIdentifier_rid | SparkProfileIdentifier_name | SparkProfileIdentifier_nameConstrained;
interface SparkProfileIdentifierConstraint_sameProfileFamily {
    type: "sameProfileFamily";
    sameProfileFamily: Void;
}
interface SparkProfileIdentifierConstraint_allowedProfileNames {
    type: "allowedProfileNames";
    allowedProfileNames: AllowedProfileNamesConstraint;
}
type SparkProfileIdentifierConstraint = SparkProfileIdentifierConstraint_sameProfileFamily | SparkProfileIdentifierConstraint_allowedProfileNames;
type SparkProfileName = string;
/**
 * A spark profile identified by name with an associated constraint.
 */
interface SparkProfileNameConstrained {
    constraint: SparkProfileIdentifierConstraint;
    name: SparkProfileName;
}
type SparkProfileRid = string;
interface SparkProfileShape {
    about: LocalizedTitleAndDescription;
    constraints?: SparkProfileConstraint | null | undefined;
}
/**
 * This specifies that the installed profile will govern data peered to this specific remote
 * system and namespace pair.
 */
interface SpecificRemoteStrategy {
    remoteNamespace: NamespaceRid;
    remoteSystem: SystemId;
}
interface SpecsSettings {
    discovery: DiscoverySettings;
    isStrictFolderTrackingModeEnabled?: boolean | null | undefined;
    targetEnvironment?: TargetEnvironment | null | undefined;
}
interface SpreadsheetDecodeFormat_xlsx {
    type: "xlsx";
    xlsx: XlsxFormat;
}
type SpreadsheetDecodeFormat = SpreadsheetDecodeFormat_xlsx;
interface SpreadsheetSchema {
    format: SpreadsheetDecodeFormat;
}
/**
 * Creates a SQL Worksheet
 */
interface SqlWorksheetCreateBlockRequest {
    rid: string;
    version: SqlWorksheetVersion;
}
/**
 * Worksheet with SQL content.
 * They are used to run sql analytics, create datasets, or back stored procedures and SQL functions
 */
interface SqlWorksheetEntityIdentifier {
    sqlWorksheetRid: string;
    version: string;
}
interface SqlWorksheetShape {
    about: LocalizedTitleAndDescription;
}
interface SqlWorksheetVersion_uuid {
    type: "uuid";
    uuid: string;
}
type SqlWorksheetVersion = SqlWorksheetVersion_uuid;
interface StableBlockKey_rid {
    type: "rid";
    rid: string;
}
/**
 * Key to uniquely identify blocks that should share the same block IDs across versions of a block set. Block IDs
 * are reused from a previous version if the stable block key and block type are the same.
 */
type StableBlockKey = StableBlockKey_rid;
/**
 * This configuration indicates that on functions block installation...
 * (1) The function version that is pre-allocated is always the source function version. If there is a version
 * conflict (e.g., from releases after unlocking an installation, reconfiguring an installation, etc.), then
 * a new function RID will be pre-allocated.
 *
 * (2) The API name that is pre-allocated is always the source API name. If there is an API name conflict with
 * another existing function in the target location, then an error is thrown.
 *
 * This configuration is encouraged in production mode installations to ensure stability of function versions
 * and API names.
 */
interface StableFunctionsApiStabilityConfiguration {
}
/**
 * A stable identifier for a shape, provided by integrations during packaging.
 * Typically used for shapes that represent parametrization values, or when integrations want to otherwise
 * deduplicate shapes explicitly.
 * Examples include:
 * - Parameter shapes: Example for workshop would be the variable ID that a parameter
 * is associated with. In workshop as long as the variable is not deleted its ID remains the same every
 * time you package a workshop.
 * - Markings ids: Example include a semantic identifier such as `oms.used-marking.<dataset-locator>` for the
 * marking. Rather than creating a shape based on the used markings in the source, a shape is created for
 * each separate marking id.
 */
type StableShapeIdentifier = string;
/**
 * Within a parent shape's group, one or more inputs had a recommendation to `upstream`
 * whose mapped upstream outputs no longer exist on the upstream's resolved version.
 * Aggregated per upstream so a parent that lost N children produces one entry, not N.
 */
interface StaleRecommendation {
    source: ExternalRecommendationSource;
    staleMappings: Record<InputBlockSetShapeId, OutputBlockSetShapeId>;
    upstream: ProductGroupMemberRid;
}
interface StaticDatasetCreateBlockRequest {
    branch: string;
    datasetRid: string;
    endTransactionRid?: string | null | undefined;
}
/**
 * A stemma code repository. Currently this type should only be used to identify external transforms.
 */
interface StemmaRepositoryType {
}
interface StoredProcedureCreateBlockRequest {
    specVersionUuid: string;
    storedProcedureRid: string;
}
/**
 * Stored Procedure used to store SQL
 */
interface StoredProcedureEntityIdentifier {
    specVersion: string;
    storedProcedureRid: string;
}
interface StoredProcedureShape {
    about: LocalizedTitleAndDescription;
}
interface StoreMetadata {
    categories: Array<Category>;
    displayName?: StoreName | null | undefined;
    linkedStores: Array<MarketplaceRid>;
    requireApprovals?: boolean | null | undefined;
}
type StoreName = string;
interface StreamDatasetCreateBlockRequest {
    branch: string;
    streamDatasetRid: string;
    viewRid?: string | null | undefined;
}
interface StreamingVideoContainerFormat_webm {
    type: "webm";
    webm: WebmStreamingFormat;
}
interface StreamingVideoContainerFormat_cmaf {
    type: "cmaf";
    cmaf: CmafStreamingFormat;
}
type StreamingVideoContainerFormat = StreamingVideoContainerFormat_webm | StreamingVideoContainerFormat_cmaf;
interface StreamingVideoSchema {
    format: StreamingVideoContainerFormat;
}
interface StreamLocator {
    branch: string;
    rid: string;
}
interface StreamLocatorIdentifier {
    branch?: string | null | undefined;
    rid: string;
}
/**
 * In strict folder tracking mode only folder discovery specs are supported. The product had a different type of
 * discovery spec.
 */
interface StrictFolderTrackingInvalidDiscoverySpec {
    discoverySpec: DiscoverySpec;
}
/**
 * In strict folder tracking mode all outputs need to be either discovered or pulled in as dependencies. The
 * given output spec had neither discovery or dependency provenance.
 */
interface StrictFolderTrackingInvalidProvenance {
    outputSpec: OutputSpec;
    provenance: Array<OutputSpecProvenance>;
}
/**
 * In strict folder tracking mode there needs to be exactly one discovery spec. The product has multiple
 * discovery specs.
 */
interface StrictFolderTrackingMultipleDiscoverySpecs {
    discoverySpecs: Array<DiscoverySpec>;
}
/**
 * In strict folder tracking mode there needs to be exactly one discovery spec. The product has none.
 */
interface StrictFolderTrackingNoDiscoverySpec {
}
/**
 * StringListType specifies that this parameter must be a list of Strings.
 */
interface StringListType {
}
interface StringMismatchError {
    actual: string;
    expected: string;
}
/**
 * StringType specifies that this parameter must be a String.
 */
interface StringType {
}
type StringValue = string;
type StringVersion = string;
interface StructFieldBaseParameterType_boolean {
    type: "boolean";
    boolean: BooleanType;
}
interface StructFieldBaseParameterType_integer {
    type: "integer";
    integer: IntegerType;
}
interface StructFieldBaseParameterType_long {
    type: "long";
    long: LongType;
}
interface StructFieldBaseParameterType_double {
    type: "double";
    double: DoubleType;
}
interface StructFieldBaseParameterType_string {
    type: "string";
    string: StringType;
}
interface StructFieldBaseParameterType_geohash {
    type: "geohash";
    geohash: GeohashType;
}
interface StructFieldBaseParameterType_geoshape {
    type: "geoshape";
    geoshape: GeoshapeType;
}
interface StructFieldBaseParameterType_timestamp {
    type: "timestamp";
    timestamp: TimestampType;
}
interface StructFieldBaseParameterType_date {
    type: "date";
    date: DateType;
}
interface StructFieldBaseParameterType_objectReference {
    type: "objectReference";
    objectReference: ObjectReferenceType;
}
/**
 * All of the possible types for fields of a Struct Parameter. This should be the intersection of allowed struct
 * property field types (https://www.palantir.com/docs/foundry/object-link-types/structs-overview/), and the
 * inhabitants of the BaseParameterType union.
 */
type StructFieldBaseParameterType = StructFieldBaseParameterType_boolean | StructFieldBaseParameterType_integer | StructFieldBaseParameterType_long | StructFieldBaseParameterType_double | StructFieldBaseParameterType_string | StructFieldBaseParameterType_geohash | StructFieldBaseParameterType_geoshape | StructFieldBaseParameterType_timestamp | StructFieldBaseParameterType_date | StructFieldBaseParameterType_objectReference;
type StructFieldRid = string;
interface StructFieldTypeUnsupported {
    unsupportedFieldTypes: Array<string>;
}
/**
 * StructListType specifies that this parameter must be a list of Structs.
 */
interface StructListType {
    structFieldTypes: Record<StructParameterFieldApiName, StructFieldBaseParameterType>;
}
/**
 * An API name that identifies a struct field in a struct parameter. Note that this api name is specific to the
 * action type and does not need to match the api name on the struct property type.
 */
type StructParameterFieldApiName = string;
/**
 * Represents a struct property, which is an ordered list of keys and values used to model data
 * with related components as part of a single entity (closely mimics the composite property type from
 * the Gotham ontology). Unlike OMS struct property type, we only did not include the struct field API
 * names as part of the type (similar to how other property types do not include their API names).
 * This is because we only require the types and the ordering of the struct fields to match.
 * Additionally, note that certain types are not supported as struct fields, but they are validated
 * in code even though their corresponding ObjectPropertyTypes might be allowed by the API shape here.
 * (See the list of supported struct field types here:
 * https://www.palantir.com/docs/foundry/object-link-types/structs-overview/)
 */
interface StructPropertyType {
    structFieldTypes: Array<ObjectPropertyType>;
}
/**
 * StructType specifies that this parameter must be a Struct.
 */
interface StructType {
    structFieldTypes: Record<StructParameterFieldApiName, StructFieldBaseParameterType>;
}
/**
 * Represents the base type of a struct value type, which is an ordered list of keys and base types used to model
 * data with related components as part of a single entity. Field names are not included as part of this type. As
 * a result, only the types and the ordering of fields are required to match.
 */
interface StructV2BaseType {
    structFieldTypes: Array<BaseType>;
}
interface SubmitJobDraftRequest {
}
interface SubmitJobDraftResponse {
}
interface SuccessGranularOutputSpecResult {
    blockSetBlockInstanceId?: BlockSetBlockInstanceId | null | undefined;
}
/**
 * Similar to the `MarkingType` enum in Multipass, but we include a third `ONLY_ORGANIZATION` type that only
 * supports organization markings. The `MANDATORY` type supports both "normal" mandatory markings and
 * organization markings, beacuse in the Multipass API, organization markings are treated as a special type of
 * mandatory markings.
 */
type SupportedMarkingsType = "MANDATORY" | "CBAC" | "ONLY_ORGANIZATION";
/**
 * Similar to the `MarkingType` enum in Multipass, but we distinguish organization markings from non-organization
 * mandatory markings.
 *
 * - `MANDATORY_NOT_ORGANIZATION`: Supports only mandatory markings (not organization markings).
 * - `ORGANIZATION`: Supports organization markings.
 * - `CBAC`: Supports CBAC markings.
 */
type SupportedMarkingsTypeV2 = "MANDATORY_NOT_ORGANIZATION" | "ORGANIZATION" | "CBAC";
/**
 * Unique identifier for a Multipass instance.
 */
type SystemId = string;
interface TabularDatasourceInputIdentifier {
    datasource: DatasourceLocatorIdentifier;
    supportedTypes: Array<TabularDatasourceType>;
}
interface TabularDatasourceInputShape {
    about: LocalizedTitleAndDescription;
    schema: Array<DatasourceColumnReference>;
    supportedTypes: Array<TabularDatasourceType>;
}
interface TabularDatasourceOutputIdentifier {
    buildRequirements?: DatasourceBuildRequirements | null | undefined;
    datasource: DatasourceLocatorIdentifier;
}
interface TabularDatasourceOutputShape {
    about: LocalizedTitleAndDescription;
    buildRequirements?: DatasourceBuildRequirements | null | undefined;
    schema: Array<DatasourceColumnReference>;
    type: TabularDatasourceType;
}
type TabularDatasourceReference = BlockInternalId;
/**
 * Shape Id that was resolved for the TabularDatasource does not match the shape id expected.
 */
interface TabularDatasourceReferenceMismatch {
    actual: TabularDatasourceReference;
    expected: TabularDatasourceReference;
}
/**
 * A tabular datasource was referenced for which the shape id could not be resolved. This is typical if the
 * referenced tabular datasource has not been included as an input/output in the block.
 */
interface TabularDatasourceReferenceUnresolvable {
    actual: DatasourceLocator;
    expected: TabularDatasourceReference;
}
type TabularDatasourceType = "DATASET" | "RESTRICTED_VIEW" | "STREAM" | "VIRTUAL_TABLE" | "DIRECT_SOURCE";
/**
 * The datasource type is not among those declared as supported by the block.
 */
interface TabularDatasourceTypeNotSupported {
    supportedTypes: Array<TabularDatasourceType>;
    type: TabularDatasourceType;
}
interface Tag {
    category: CategoryRid;
    isImported: boolean;
    name: LocalizedName;
    rid: TagRid;
}
interface TagOrDigest_tag {
    type: "tag";
    tag: string;
}
interface TagOrDigest_digest {
    type: "digest";
    digest: string;
}
type TagOrDigest = TagOrDigest_tag | TagOrDigest_digest;
type TagRid = string;
interface TargetCompassInstallLocation {
    namespaceRid: NamespaceRid;
}
interface TargetCompassInstallLocationV2 {
    newProjectOrExistingFolder: NewProjectOrExistingFolderV2;
}
/**
 * The target environment the resources should be packaged for. Note that all products should support cloud,
 * edge should be considered an additional "add on".
 *
 * CLOUD: Product only needs to support cloud.
 * EDGE/EDGE_DEPRECATED: Product needs to support both cloud _and_ edge.
 *
 * Note that for most blocks, the packaging is supposed to be compatible with both cloud and edge. This should
 * only be used for blocks that need to be packaged differently depending on the target environment.
 */
type TargetEnvironment = "CLOUD" | "EDGE" | "EDGE_DEPRECATED";
interface TargetInputShape {
    resolvedShape?: ResolvedBlockSetInputShape | null | undefined;
}
/**
 * A snapshot of a target installation within the draft, reflecting the cumulative state of its target version
 * and input mappings across all modifications made to the draft. Modifications are then processed asynchronously
 * until the resolved draft is consistent with these latest target states.
 */
interface TargetInstallation {
    installationRid: BlockSetInstallationRid;
    resolvedOutputShapesToAttach: Record<OutputBlockSetShapeId, ResolvedBlockSetOutputShape>;
    targetInputShapes: Record<InputBlockSetShapeId, TargetInputShape>;
    targetLocation: TargetInstallLocationV3;
    targetVersion: InstallableBlockSetVersionId;
}
/**
 * Optional, non-declarative overrides for installation properties. Each field is optional -
 * absent fields preserve the existing value, present fields replace it.
 */
interface TargetInstallationOverrides {
    targetLocation?: SetTargetInstallLocation | null | undefined;
}
/**
 * Provide an existing installation whose current state and resolved shapes will be copied forward, with the
 * target version we want to install.
 */
interface TargetInstallationSpec {
    installationRid: BlockSetInstallationRid;
    targetVersion: InstallableBlockSetVersionId;
}
interface TargetInstallationSummary {
    installationRid: BlockSetInstallationRid;
    targetVersion: InstallableBlockSetVersionId;
}
/**
 * A target install location to install a set of blocks into. This represents a location that something is
 * *going* to be installed into, which is different from `BlockInstallLocation` and `BlockSetInstallLocation`
 * which both represent the location that something *has* been installed into.
 */
interface TargetInstallLocation {
    compass: TargetCompassInstallLocation;
    ontology?: OntologyInstallLocation | null | undefined;
}
/**
 * The target install location provided in the request does not match the current location of an existing block
 * set installation.
 */
interface TargetInstallLocationDoesNotMatchCurrentLocation {
    currentInstallLocation: BlockSetInstallLocation;
    targetInstallLocation: TargetInstallLocation;
}
/**
 * A target install location to install a block set into. This represents a location that something is *going* to
 * be installed into, which is different from `BlockInstallLocation` and `BlockSetInstallLocation` which both
 * represent the location that something *has* been installed into.
 */
interface TargetInstallLocationV2 {
    compass: TargetCompassInstallLocationV2;
    ontology?: OntologyInstallLocation | null | undefined;
}
/**
 * The target install location that will be used during this installation. The block set installation resource
 * must already exist and be within the stated Compass location. The Ontology location can be set or overridden
 * in the context of a job.
 */
interface TargetInstallLocationV3 {
    compass: BlockSetCompassInstallLocation;
    ontology?: OntologyInstallLocation | null | undefined;
}
/**
 * The ontology rid of the install location is associated with a different namespace.
 */
interface TargetOntologyIsNotLinkedToTargetNamespace {
    requestedOntologyRid: OntologyRid;
    targetNamespace: NamespaceRid;
}
/**
 * The location that a block set will be registered in.
 */
interface TargetRegistrationLocation {
    compass: CompassInstallLocation;
    ontology?: OntologyInstallLocation | null | undefined;
}
/**
 * Not yet implemented by the corresponding service
 */
interface TaurusCreateBlockRequest {
    rid: string;
    workflowVersion?: string | null | undefined;
}
interface TaurusWorkflowIdentifier_rid {
    type: "rid";
    rid: TaurusWorkflowRidIdentifier;
}
type TaurusWorkflowIdentifier = TaurusWorkflowIdentifier_rid;
type TaurusWorkflowRidIdentifier = string;
/**
 * Taurus workflow that is referenced by taurus workshop widget.
 */
interface TaurusWorkflowShape {
    about: LocalizedTitleAndDescription;
}
interface TemplatesContourCreateBlockRequest {
    contourAnalysisRid: string;
}
interface TemplatesCreateBlockRequest_contour {
    type: "contour";
    contour: TemplatesContourCreateBlockRequest;
}
type TemplatesCreateBlockRequest = TemplatesCreateBlockRequest_contour;
interface ThirdPartyApplicationCreateBlockRequest {
    applicationVersion?: number | null | undefined;
    thirdPartyApplicationRid: string;
}
interface ThirdPartyApplicationEntityIdentifier {
    rid: ThirdPartyApplicationRid;
}
type ThirdPartyApplicationReference = BlockInternalId;
type ThirdPartyApplicationRid = string;
interface ThirdPartyApplicationShape {
    about: LocalizedTitleAndDescription;
}
interface TiffFormat {
}
/**
 * TimeSeriesReferenceType specifies that this parameter must be a TimeSeriesReference.
 */
interface TimeSeriesReferenceType {
}
interface TimeSeriesSyncCreateBlockRequest {
    rid: string;
    version?: string | null | undefined;
}
type TimeSeriesSyncRid = string;
interface TimeSeriesSyncShape {
    about: LocalizedTitleAndDescription;
    type?: TimeSeriesSyncType | null | undefined;
}
type TimeSeriesSyncType = "NUMERIC" | "CATEGORICAL";
/**
 * TimestampListType specifies that this parameter must be a list of Timestamps.
 */
interface TimestampListType {
}
/**
 * TimestampType specifies that this parameter must be a Timestamp.
 */
interface TimestampType {
}
/**
 * We current only provide support for overriding the fallback title, not the localized mappings.
 */
interface TitleOverride {
    fallbackTitle: string;
}
interface TitleOverrideRequest_set {
    type: "set";
    set: TitleOverride;
}
interface TitleOverrideRequest_remove {
    type: "remove";
    remove: Void;
}
type TitleOverrideRequest = TitleOverrideRequest_set | TitleOverrideRequest_remove;
interface ToBeAppliedExternalRecommendationV2 {
    recommendationSource: ExternalRecommendationSource;
    upstreamBlockSet: BlockSetId;
    upstreamBlockSetInstallation: BlockSetReference;
}
interface TopLevelAutomapping {
}
interface TransformsCreateBlockRequest {
    jobSpecRid: string;
}
interface TransformsJobSpecShape {
    about: LocalizedTitleAndDescription;
}
/**
 * If included in a Cipher License, the user has the ability to encrypt or decrypt (depending on the RequestType)
 * in Transforms as an input parameter. This effectively grants access to the keys.
 */
interface TransformsRequestPermit {
    requestType: RequestType;
}
type TransportBlockSetInputGroups = Record<BlockSetInputGroupId, InputGroupBlockSetMappingInfo>;
type TransportBlockSetInputShapes = Record<InputBlockSetShapeId, TransportInputBlockSetMappingInfo>;
type TransportBlockSetOutputShapes = Record<OutputBlockSetShapeId, TransportOutputBlockSetMappingInfo>;
/**
 * Used for transport. Should not be included in the API
 */
interface TransportBlockSetToBlockMapping {
    inputGroups: TransportBlockSetInputGroups;
    inputShapes: TransportBlockSetInputShapes;
    internalRecommendations: Array<BlockSetInternalRecommendation>;
    outputShapes: TransportBlockSetOutputShapes;
    shapeDependencies: Array<BlockSetShapeDependencies>;
}
/**
 * Transportable version of InputBlockSetMappingInfo. Does not include any resolved shapes.
 */
interface TransportInputBlockSetMappingInfo {
    backingShapes: Array<ShapeReference>;
    isOptional: boolean;
    metadata?: InputBlockSetShapeMetadata | null | undefined;
    shape: BlockSetInputShape;
}
/**
 * Transportable version of OutputBlockSetMappingInfo. Does not include any resolved shapes.
 */
interface TransportOutputBlockSetMappingInfo {
    backingShape: ShapeReference;
    producedByBlockType: BlockType;
    shape: BlockSetOutputShape;
}
/**
 * Metadata about the packaging and publication process for a block set version.
 */
interface TransportPackagingMetadata {
    publishedByDifferentUser: boolean;
}
interface TransportReleaseMetadata {
    activeRecalls: Record<RecallId, RecallVersionsAnnouncement>;
    releaseMetadata: Record<BlockSetVersionId, BlockSetVersionReleaseMetadata>;
}
interface TransportVersionedMarketplaceMetadata {
    metadata: StoreMetadata;
    version: MarketplaceMetadataVersion;
}
interface TsVideoContainerFormat {
}
interface TxtFormat {
}
/**
 * This is a weakly typed error item, which is used by integrating services to surface information to users.
 */
interface TypedBlockInstallServiceValidationError {
    blockType: BlockType;
    error: TypedBlockInstallValidationError;
    traceId?: string | null | undefined;
}
interface TypedBlockInstallValidationError {
    error: any;
    fallbackMessage: string;
    severity: ErrorSeverity;
}
/**
 * The actual Function requires additional inputs beyond those specified on the Function shape.
 * The function would still be compatible if these inputs were optional, but this error indicates
 * there are some that are not optional.
 */
interface UnexpectedNonOptionalFunctionInput {
    inputIndex: number;
}
/**
 * The actual Function requires additional inputs beyond those specified on the Function shape.
 * The function would still be compatible if these inputs were optional, but this error indicates
 * there are some that are not optional.
 */
interface UnexpectedNonOptionalFunctionInputV2 {
    inputName: string;
}
/**
 * One or more input shapes on a downstream member have no valid fulfilling recommendation
 * and no other member produces a matching output. All such inputs are aggregated into
 * a single finding per member, grouped by rollup parent shape.
 *
 * A recommendation is considered invalid (and therefore non-fulfilling) when it points at
 * an upstream output that no longer exists on the upstream's resolved version. Such inputs
 * are surfaced via `staleRecommendations` on each shape entry.
 *
 * Finding level is ERROR when any unfulfilled input lacks a preset, INFO otherwise.
 * Ignored and optional inputs produce no finding. When another member does produce a
 * matching output, a MissingRecommendation finding is emitted instead.
 */
interface UnfulfilledInput {
    downstream: ProductGroupMemberRid;
    unfulfilledShapes: Array<UnfulfilledInputShape>;
}
/**
 * Unfulfilled inputs grouped by parent shape. When the parent shape is unfulfilled,
 * `missingChildShapeIds` is empty — the parent-level entry covers any unfulfilled children.
 * Otherwise, `missingChildShapeIds` lists the unfulfilled children of this parent.
 */
interface UnfulfilledInputShape {
    missingChildShapeIds: Array<InputBlockSetShapeId>;
    parentShapeId: InputBlockSetShapeId;
    staleRecommendations: Array<StaleRecommendation>;
}
/**
 * Validation error which does not disable the automation but is also not converted into a constraint failure
 *
 * This is typed as any as we accidentally stored two different types in alta (PDS-456083), and we need to
 * support both to ensure that we can continue to read entries from the database. All new validation failures
 * should use UnhandledValidationFailureV2, which is strongly typed.
 */
type UnhandledValidationFailure = any;
/**
 * Validation error which does not disable the automation but is also not converted into a constraint failure
 */
type UnhandledValidationFailureV2 = ValidateInstallBlocksResponse;
/**
 * Validation error which does not disable the automation but is also not converted into a constraint failure
 */
type UnhandledValidationFailureV3 = ValidateInstallBlockSetsResponse;
interface UninstallError_nonEmptyCompassInstallLocation {
    type: "nonEmptyCompassInstallLocation";
    nonEmptyCompassInstallLocation: NonEmptyCompassInstallLocation;
}
type UninstallError = UninstallError_nonEmptyCompassInstallLocation;
interface UninstallMode_permanentlyDelete {
    type: "permanentlyDelete";
    permanentlyDelete: PermanentlyDeleteUninstallOptions;
}
interface UninstallMode_fieldTestPermanentlyDelete {
    type: "fieldTestPermanentlyDelete";
    fieldTestPermanentlyDelete: PermanentlyDeleteUninstallOptions;
}
interface UninstallMode_softDelete {
    type: "softDelete";
    softDelete: SoftDeleteUninstallOptions;
}
type UninstallMode = UninstallMode_permanentlyDelete | UninstallMode_fieldTestPermanentlyDelete | UninstallMode_softDelete;
interface UninstallRequest {
    uninstallMode: UninstallMode;
}
interface UninstallResponse_success {
    type: "success";
    success: UninstallResponseSuccess;
}
interface UninstallResponse_failure {
    type: "failure";
    failure: UninstallResponseFailure;
}
type UninstallResponse = UninstallResponse_success | UninstallResponse_failure;
interface UninstallResponseFailure {
    errors: Array<BlockSetShapesRemovalError>;
    otherErrors: Array<UninstallError>;
    successfullyDeletedOutputs: Record<OutputBlockSetShapeId, ResolvedOutputShape>;
}
interface UninstallResponseSuccess {
}
interface UnknownMarketplaceCreateBlockVersionError {
    unsafeMessage: string;
}
interface UnresolvableBlockSetCycle {
    blockSetInstallations: Array<BlockSetReference>;
}
/**
 * The unresolved user-intent encoding the target installations. This is always returned synchronously on
 * updates from the user.
 */
interface UnresolvedJobDraft {
    additionalRecommendationsToConsider: Array<UpstreamRecommendation>;
    installations: Array<TargetInstallation>;
    rid: BlockSetInstallationJobRid;
}
/**
 * A member of a product group, representing a block set with a source and backing version policy.
 */
interface UnresolvedProductGroupMember {
    memberRid: ProductGroupMemberRid;
    source: ProductGroupMemberSpec;
}
/**
 * This is a placeholder type for when we don't care about the specific type of a parameter, simply representing
 * the presence of an argument. We use this as a minimal way to express compatibility between input and
 * output function shapes, mostly  to allow for more complex types to be used in the future without breaking
 * existing stored shapes.
 */
interface UnspecifiedParameterType {
}
interface UnusedShapeStatusEntry {
    resolvedOutputShape: ResolvedBlockSetOutputShape;
}
interface UpdateAboutRequest_set {
    type: "set";
    set: LocalizedTitleAndDescription;
}
type UpdateAboutRequest = UpdateAboutRequest_set;
interface UpdateBlockSetMetadataRequest {
    mavenProductId: MavenProductId;
}
interface UpdateBlockSetMetadataResponse {
}
/**
 * Request to update the changelog of a block set version.
 */
interface UpdateBlockSetVersionChangelogRequest {
    changelog: Changelog;
}
interface UpdateBlockSetVersionChangelogResponse {
}
/**
 * Request to update the documentation of a block set version. Only fields which are specified in the request
 * will be updated, all other fields will be left untouched.
 */
interface UpdateBlockSetVersionDocumentationRequest {
    attachments?: Array<AttachmentId> | null | undefined;
    freeForm?: FreeFormDocumentation | null | undefined;
    freeFormSections?: FreeFormDocumentationSections | null | undefined;
    links?: Links | null | undefined;
    localizedFreeFormSections?: LocalizedFreeFormDocumentationSections | null | undefined;
    removeThumbnail?: boolean | null | undefined;
    thumbnail?: AttachmentId | null | undefined;
}
interface UpdateBlockSetVersionDocumentationResponse {
}
/**
 * The last time the job was updated up to the end of reconcile. This is to ensure consistency as builds and
 * indexing are included in the duration of installations.
 */
type UpdatedAtTimestamp = string;
interface UpdateDefaultInstallationSettingsRequest_set {
    type: "set";
    set: DefaultInstallationSettings;
}
interface UpdateDefaultInstallationSettingsRequest_remove {
    type: "remove";
    remove: Void;
}
type UpdateDefaultInstallationSettingsRequest = UpdateDefaultInstallationSettingsRequest_set | UpdateDefaultInstallationSettingsRequest_remove;
/**
 * An identifier for tracking the processing of external recommendation refresh requests. Increases
 * monotonically with each update, such that we guarantee an event has been processed or superseded by a more
 * recent update, if the latestProcessedUpdateId is greater than or equal to its ID.
 *
 * Requests are always guaranteed to be processed in order, but there is no guarantee all requests will be
 * processed. If multiple requests are submitted whilst the last update is still being processed, we will process
 * the latest request only.
 */
type UpdateExternalRecsRequestId = number;
/**
 * Request to declaratively set the target state for all the installations in an existing draft, e.g., setting
 * the input mappings. We will synchronously return the new target state requested by the user, which is a
 * culmination of this and other update requests. The fully resolved result of these updates will be returned
 * asynchronously.
 * Cannot be used to add or remove installations, for this use `modifyJobDraftInstallations`. All installations
 * currently in the draft must be included. Throws `JobDraftInstallationsNotInDraft` if unknown installations
 * are added, and `JobDraftInstallationsMissingFromUpdateRequest` if any existing installations are omitted.
 */
interface UpdateJobDraftRequest {
    installations: Array<SetTargetInstallation>;
}
interface UpdateJobDraftResponse {
    draft: UnresolvedJobDraft;
    metadata: JobDraftMetadata;
}
/**
 * Includes a registered public key and a list of maven coordinates that will override the existing list of
 * maven coordinates that the key is able to verify.
 */
interface UpdateKeyRequest {
    mavenCoordinates: MavenCoordinates;
    publicKey: SigningPublicKey;
}
interface UpdateKeyResponse {
}
interface UpdateMarketplaceMetadataVersionRequest_set {
    type: "set";
    set: MarketplaceMetadataVersion;
}
interface UpdateMarketplaceMetadataVersionRequest_remove {
    type: "remove";
    remove: Void;
}
type UpdateMarketplaceMetadataVersionRequest = UpdateMarketplaceMetadataVersionRequest_set | UpdateMarketplaceMetadataVersionRequest_remove;
interface UpdatePackagingSettingsRequest_set {
    type: "set";
    set: PackagingSettings;
}
interface UpdatePackagingSettingsRequest_remove {
    type: "remove";
    remove: Void;
}
type UpdatePackagingSettingsRequest = UpdatePackagingSettingsRequest_set | UpdatePackagingSettingsRequest_remove;
/**
 * Request to update the metadata of block set version. Output specs will be unchanged.
 * Declarative update that overrides any existing values with those in the request.
 */
interface UpdatePendingBlockSetVersionMetadataRequest {
    about: LocalizedTitleAndDescription;
    defaultInstallationSettings?: DefaultInstallationSettings | null | undefined;
    marketplaceMetadataVersion?: MarketplaceMetadataVersion | null | undefined;
    packagingSettings?: PackagingSettings | null | undefined;
    tagsV2: BlockSetCategorizedTags;
    typedTags: Array<TagRid>;
    versionIncrement?: VersionIncrement | null | undefined;
}
/**
 * Patch-style update of block set version metadata. Only fields that are present in the
 * request will be updated. Absent fields are left unchanged.
 */
interface UpdatePendingBlockSetVersionMetadataRequestV3 {
    about?: UpdateAboutRequest | null | undefined;
    defaultInstallationSettings?: UpdateDefaultInstallationSettingsRequest | null | undefined;
    marketplaceMetadataVersion?: UpdateMarketplaceMetadataVersionRequest | null | undefined;
    packagingSettings?: UpdatePackagingSettingsRequest | null | undefined;
    tagsV2?: UpdateTagsV2Request | null | undefined;
    typedTags?: UpdateTypedTagsRequest | null | undefined;
    versionIncrement?: UpdateVersionIncrementRequest | null | undefined;
}
interface UpdatePendingBlockSetVersionMetadataResponse {
}
interface UpdatePendingBlockSetVersionMetadataResponseV3 {
}
/**
 * Request to update the output specs of a pending block set version.
 */
interface UpdatePendingBlockSetVersionSpecsRequest {
    discoverySpecs: Array<DiscoverySpec>;
    outputSpecs: Array<OutputSpec>;
    refreshConfig?: RefreshSpecsConfig | null | undefined;
    settings?: SpecsSettings | null | undefined;
    shouldRefresh: boolean;
}
/**
 * An identifier that can be used to track the processing of the asynchronous update request. Increases
 * monotonically with each update, such that we guarantee an event has been processed or superseded by a more
 * recent update, if the latestProcessedUpdateId is greater than or equal to its ID.
 *
 * Requests are always guaranteed to be processed in order, but there is no guarantee all requests will be
 * processed. If multiple requests are submitted whilst the last update is still materializing, we will process
 * the latest request only.
 */
type UpdatePendingBlockSetVersionSpecsRequestId = number;
interface UpdatePendingBlockSetVersionSpecsResponse {
    id: UpdatePendingBlockSetVersionSpecsRequestId;
}
/**
 * Sets either the title or description or both. Will only change the override(s) that are populated.
 */
interface UpdatePendingInputShapeAboutRequest {
    description?: DescriptionOverrideRequest | null | undefined;
    title?: TitleOverrideRequest | null | undefined;
}
/**
 * Updates any part of the pending input shape metadata. Will only change the overrides(s) that are populated.
 */
interface UpdatePendingInputShapeMetadataRequest {
    presets?: UpdatePresetsRequest | null | undefined;
}
interface UpdatePlaceholderRequest {
    blockSetInputShape: BlockSetInputShape;
    datasetRid: string;
}
interface UpdatePlaceholdersRequest {
    inputShapesToUpdatePlaceholdersFor: Record<InputBlockSetShapeId, UpdatePlaceholderRequest>;
}
interface UpdatePlaceholdersResponse {
    resolvedInputShapes: Record<InputBlockSetShapeId, ResolvedBlockSetInputShape>;
}
interface UpdatePresetsRequest_set {
    type: "set";
    set: SetInputPresetRequest;
}
interface UpdatePresetsRequest_remove {
    type: "remove";
    remove: Void;
}
type UpdatePresetsRequest = UpdatePresetsRequest_set | UpdatePresetsRequest_remove;
/**
 * Update metadata for a single recommendation defined by a given source, target block set version, marketplace
 * and upstream block set.
 */
interface UpdateRecommendationMetadataRequest {
    displayMetadata: ExternalRecommendationDisplayMetadata;
    mavenProductDependencyRequirement?: ExternalRecommendationMavenDependencyRequirement | null | undefined;
    source: ExternalRecommendationSource;
    targetBlockSetVersion: BlockSetVersionId;
    targetMarketplaceRid: MarketplaceRid;
    upstreamBlockSet: BlockSetId;
}
interface UpdateRecommendationMetadataResponse {
}
interface UpdateTagsV2Request_set {
    type: "set";
    set: BlockSetCategorizedTags;
}
type UpdateTagsV2Request = UpdateTagsV2Request_set;
interface UpdateTypedTagsRequest_set {
    type: "set";
    set: Array<TagRid>;
}
type UpdateTypedTagsRequest = UpdateTypedTagsRequest_set;
interface UpdateVersionIncrementRequest_set {
    type: "set";
    set: VersionIncrement;
}
interface UpdateVersionIncrementRequest_remove {
    type: "remove";
    remove: Void;
}
type UpdateVersionIncrementRequest = UpdateVersionIncrementRequest_set | UpdateVersionIncrementRequest_remove;
interface UpdateVisibilityRequest_set {
    type: "set";
    set: BlockSetShapeVisibility;
}
interface UpdateVisibilityRequest_remove {
    type: "remove";
    remove: Void;
}
type UpdateVisibilityRequest = UpdateVisibilityRequest_set | UpdateVisibilityRequest_remove;
/**
 * An upgrade in the request constains a singleton product that has multiple installs in the namespace.
 * There should only be one installation of a singleton per namespace, but during validation we found multiple.
 * Because this is an upgrade this is non-blocking.
 */
interface UpgradeOfSingletonBlockSetThatIsInstalledMultipleTimes {
    otherInstallations: Array<BlockSetInstallationRid>;
}
/**
 * NOTE: Only use DOWNTIME. NO_DOWNTIME doesn't actually do anything...
 */
type UpgradeType = "DOWNTIME" | "NO_DOWNTIME";
/**
 * Planning was successful in kicking off an installation job
 */
interface UpgradingStatus {
    jobRid: BlockSetInstallationJobRid;
}
interface UploadAttachmentResponse {
    attachmentId: AttachmentId;
}
interface UploadingStatusV3 {
    hasErrors: boolean;
    hasWarnings: boolean;
}
/**
 * Used to reference an installation and recommendation source, such that external recommendations provided by
 * this upstream will be used to resolve inputs for installations within this job draft.
 * These upstream installations must not also be members of the target installations in the draft.
 */
interface UpstreamRecommendation {
    blockSetInstallation: BlockSetInstallationRid;
    recommendationSource: ExternalRecommendationSource;
}
type Url = string;
/**
 * A versioned cross stack identifier for a user managed value type.
 */
interface UserManagedValueTypeIdentifier {
    apiName: ValueTypeApiName;
    version: ValueTypeVersion;
}
type UuidVersion = string;
interface ValidateBlockSetVersionResponse {
    validationErrors: Array<BlockSetVersionValidationError>;
}
interface ValidateInstallBlockSetsResponse {
    blockSetValidationErrors: Array<BlockSetInstallValidationErrorV2>;
    jobValidationErrors: Array<InstallationJobValidationError>;
    shapeValidationErrors: Array<InstallShapeValidationErrorV2>;
}
interface ValidateInstallBlocksResponse {
    blockSetValidationErrors: Array<BlockSetInstallValidationError>;
    validationErrors: Array<InstallValidationError>;
}
interface ValidateMarketplaceMavenGroupFailure_groupAlreadyUsed {
    type: "groupAlreadyUsed";
    groupAlreadyUsed: GroupAlreadyUsedFailure;
}
interface ValidateMarketplaceMavenGroupFailure_groupMalformed {
    type: "groupMalformed";
    groupMalformed: GroupMalformedFailure;
}
interface ValidateMarketplaceMavenGroupFailure_other {
    type: "other";
    other: OtherValidationFailure;
}
type ValidateMarketplaceMavenGroupFailure = ValidateMarketplaceMavenGroupFailure_groupAlreadyUsed | ValidateMarketplaceMavenGroupFailure_groupMalformed | ValidateMarketplaceMavenGroupFailure_other;
interface ValidateMarketplaceMavenGroupRequest {
    mavenGroup: MavenGroup;
}
interface ValidateMarketplaceMavenGroupResponse_success {
    type: "success";
    success: ValidateMarketplaceMavenGroupSuccess;
}
interface ValidateMarketplaceMavenGroupResponse_failure {
    type: "failure";
    failure: ValidateMarketplaceMavenGroupFailure;
}
type ValidateMarketplaceMavenGroupResponse = ValidateMarketplaceMavenGroupResponse_success | ValidateMarketplaceMavenGroupResponse_failure;
interface ValidateMarketplaceMavenGroupSuccess {
}
/**
 * Request to validate a product group.
 */
interface ValidateProductsRequest {
    productGroup: ProductGroupRid;
    productGroupVersionRid?: ProductGroupVersionRid | null | undefined;
}
/**
 * Response containing validation findings and an overall status.
 */
interface ValidateProductsResponse {
    findings: Array<ProductGroupValidationFinding>;
    memberVersions: Array<SnapshotMemberVersion>;
    status: ProductGroupValidationStatus;
}
interface ValidProductGroupValidationStatus {
}
/**
 * A string representing a value type's api name. Used as a stable, cross-stack identifier for service managed value types.
 */
type ValueTypeApiName = string;
/**
 * The referenced value type has a different base type than the corresponding shape.
 */
interface ValueTypeBaseTypeMismatch {
    valueTypeBaseType: string;
    valueTypeRid: string;
    valueTypeShapeBaseType: string;
}
interface ValueTypeCreateBlockRequest {
    valueTypeRid: string;
    valueTypeVersionId?: string | null | undefined;
}
/**
 * Could not find the value type with the requested rid.
 */
interface ValueTypeNotFound {
    requestedValueTypeRid: string;
}
interface ValueTypePresetResolver_userManaged {
    type: "userManaged";
    userManaged: UserManagedValueTypeIdentifier;
}
interface ValueTypePresetResolver_serviceManaged {
    type: "serviceManaged";
    serviceManaged: ServiceManagedValueTypeIdentifier;
}
/**
 * Resolver for user or service defined value types. It is necessary to separate the user and service defined
 * value types, despite being identical objects, as each type of value type is locked down by different
 * gatekeeper resources.
 */
type ValueTypePresetResolver = ValueTypePresetResolver_userManaged | ValueTypePresetResolver_serviceManaged;
type ValueTypeReference = BlockInternalId;
type ValueTypeRid = string;
interface ValueTypeShape {
    about: LocalizedTitleAndDescription;
    baseType: BaseType;
    serviceTypeIdentifier?: ServiceManagedValueTypeIdentifier | null | undefined;
}
interface ValueTypeShapeValidationError_valueTypeNotFound {
    type: "valueTypeNotFound";
    valueTypeNotFound: ValueTypeNotFound;
}
interface ValueTypeShapeValidationError_valueTypeVersionNotFound {
    type: "valueTypeVersionNotFound";
    valueTypeVersionNotFound: ValueTypeVersionNotFound;
}
interface ValueTypeShapeValidationError_valueTypeBaseTypeMismatch {
    type: "valueTypeBaseTypeMismatch";
    valueTypeBaseTypeMismatch: ValueTypeBaseTypeMismatch;
}
/**
 * Errors specific to ValueTypeShape(s).
 */
type ValueTypeShapeValidationError = ValueTypeShapeValidationError_valueTypeNotFound | ValueTypeShapeValidationError_valueTypeVersionNotFound | ValueTypeShapeValidationError_valueTypeBaseTypeMismatch;
/**
 * A string representing a value type's version. Enforced to be a semantic version.
 */
type ValueTypeVersion = string;
/**
 * A UUID representing a persisted value type version.
 */
type ValueTypeVersionId = string;
/**
 * Could not find the value type with the requested rid or at the requested version.
 */
interface ValueTypeVersionNotFound {
    requestedValueTypeVersion: string;
    valueTypeRid: string;
}
/**
 * Marketplace dependencies for a vector property
 */
interface VectorPropertyType {
    dimension?: number | null | undefined;
    supportsSearchWith: Array<VectorSimilarityFunction>;
}
type VectorSimilarityFunction = "COSINE_SIMILARITY" | "DOT_PRODUCT" | "EUCLIDEAN_DISTANCE";
/**
 * Vector Entity Identifier for generating vector shapes
 */
interface VectorWorkbookIdentifier {
    rid: string;
}
interface VectorWorkbookShape {
    about: LocalizedTitleAndDescription;
}
interface VersionedMarketplaceMetadata {
    metadata: StoreMetadata;
    version: MarketplaceMetadataVersion;
}
/**
 * Creates a Versioned Object Set
 */
interface VersionedObjectSetCreateBlockRequest {
    rid: string;
    version?: string | null | undefined;
}
/**
 * Identifies a specific version of a versioned object set.
 */
interface VersionedObjectSetEntityIdentifier {
    version: string;
    versionedObjectSetRid: string;
}
/**
 * The version packaged for that Versioned Object Set does not correspond to its latest version.
 * Only packaging latest is currently supported.
 */
interface VersionedObjectSetNotLatestError {
}
type VersionedObjectSetRid = string;
interface VersionedObjectSetShape {
    about: LocalizedTitleAndDescription;
}
type VersionedObjectSetVersion = string;
/**
 * Versioned definition of a product group.
 */
interface VersionedProductGroupDefinition {
    createdBy: MultipassUserId;
    creationTimestamp: CreationTimestamp;
    members: Array<ResolvedProductGroupMember>;
    productGroupRid: ProductGroupRid;
    productGroupVersionRid: ProductGroupVersionRid;
    semverVersion: SemverVersion;
    validationSettings: ProductGroupValidationSettings;
}
/**
 * A key that uniquely identifies a value type by its rid + version.
 */
interface VersionedValueTypeIdentifier {
    valueTypeRid: ValueTypeRid;
    valueTypeVersion?: ValueTypeVersion | null | undefined;
    valueTypeVersionId?: ValueTypeVersionId | null | undefined;
}
type VersionIncrement = "MAJOR" | "MINOR" | "PATCH";
interface VersionRangeBlockReference {
    blockId: BlockId;
    versions: BlockVersionRange;
}
interface VersionRangeBlockSetReference_external {
    type: "external";
    external: VersionRangeBlockReference;
}
interface VersionRangeBlockSetReference_internal {
    type: "internal";
    internal: BlockSetBlockInstanceId;
}
/**
 * DEPRECATED: Replaced by block set shapes internal recommendations.
 */
type VersionRangeBlockSetReference = VersionRangeBlockSetReference_external | VersionRangeBlockSetReference_internal;
interface VertexCreateBlockRequest {
    rid: string;
}
/**
 * Vertex Template that can be used to generate Graphs.
 */
interface VertexEntityIdentifier {
    rid: string;
}
/**
 * Vertex Template that can be used to generate Graphs.
 */
interface VertexTemplateShape {
    about: LocalizedTitleAndDescription;
}
interface VideoDecodeFormat_mp4 {
    type: "mp4";
    mp4: Mp4VideoContainerFormat;
}
interface VideoDecodeFormat_ts {
    type: "ts";
    ts: TsVideoContainerFormat;
}
interface VideoDecodeFormat_mov {
    type: "mov";
    mov: MovVideoContainerFormat;
}
interface VideoDecodeFormat_mkv {
    type: "mkv";
    mkv: MkvVideoContainerFormat;
}
type VideoDecodeFormat = VideoDecodeFormat_mp4 | VideoDecodeFormat_ts | VideoDecodeFormat_mov | VideoDecodeFormat_mkv;
interface VideoSchema {
    format: VideoDecodeFormat;
}
interface VirtualTableCreateBlockRequest {
    branch?: string | null | undefined;
    rid: string;
}
interface VirtualTableLocator {
    branch: string;
    rid: string;
}
interface VirtualTableLocatorIdentifier {
    branch?: string | null | undefined;
    rid: string;
}
interface Void {
}
/**
 * Represents a function that does not return a value. This is typically used for functions
 * that perform side effects (such as actions or ontology edits) without producing an output.
 */
interface VoidOutputType {
}
interface VorbisFormat {
}
interface VortexCreateBlockRequest {
    rid: string;
}
/**
 * Vortex Map Template that can be used to generate Maps.
 */
interface VortexEntityIdentifier {
    rid: string;
}
/**
 * Vortex Map Template that can be used to generate Maps.
 */
interface VortexTemplateShape {
    about: LocalizedTitleAndDescription;
}
interface WalkthroughCreateBlockRequest {
    rid: string;
}
interface WalkthroughEntityIdentifier {
    rid: string;
}
interface WalkthroughShape {
    about: LocalizedTitleAndDescription;
}
/**
 * A UUID that identifies a warehouse
 */
type WarehouseId = string;
/**
 * ID internal to a warehouse for managing marketplaces
 */
type WarehouseInternalId = string;
interface WarnProductGroupValidationStatus {
}
interface WavFormat {
}
interface WebhookEntityIdentifier {
    version: WebhookVersion;
    webhookRid: WebhookRid;
}
type WebhookRid = string;
interface WebhooksCreateBlockRequest {
    rid: string;
    version: number;
}
interface WebhookShape {
    about: LocalizedTitleAndDescription;
}
type WebhookVersion = number;
type WebmAudioCodec = "OPUS" | "VORBIS";
interface WebmAudioContainerFormat_singleStream {
    type: "singleStream";
    singleStream: SingleStreamWebmAudioContainerFormat;
}
type WebmAudioContainerFormat = WebmAudioContainerFormat_singleStream;
interface WebmStreamingFormat {
    audioCodec?: WebmAudioCodec | null | undefined;
    videoCodec: WebmVideoCodec;
}
type WebmVideoCodec = "VP8" | "VP9";
interface WebpFormat {
}
interface WidgetIdentifier_ridAndVersion {
    type: "ridAndVersion";
    ridAndVersion: WidgetRidAndVersionIdentifier;
}
type WidgetIdentifier = WidgetIdentifier_ridAndVersion;
type WidgetReference = BlockInternalId;
type WidgetRid = string;
interface WidgetRidAndVersionIdentifier {
    widgetRid: WidgetRid;
    widgetSetRid: WidgetSetRid;
    widgetSetVersion: WidgetSetVersion;
}
interface WidgetSetCreateBlockRequest {
    rid: string;
    version: string;
}
interface WidgetSetIdentifier_ridAndVersion {
    type: "ridAndVersion";
    ridAndVersion: WidgetSetRidAndVersionIdentifier;
}
type WidgetSetIdentifier = WidgetSetIdentifier_ridAndVersion;
type WidgetSetReference = BlockInternalId;
type WidgetSetRid = string;
interface WidgetSetRidAndVersionIdentifier {
    widgetSetRid: WidgetSetRid;
    widgetSetVersion: WidgetSetVersion;
}
interface WidgetSetShape {
    about: LocalizedTitleAndDescription;
    widgets: Array<WidgetReference>;
}
/**
 * A semver version string. This is user defined and supports prerelease versions
 * and build metadata.
 */
type WidgetSetVersion = string;
interface WidgetShape {
    about: LocalizedTitleAndDescription;
    widgetSet: WidgetSetReference;
}
/**
 * Used in validation error reporting for describing which DayTime failed validation
 */
type WindowStartOrEnd = "START" | "END";
interface WorkbenchTemplateCreateBlockRequest {
    rid: string;
}
interface WorkbenchTemplateIdentifier {
    rid: WorkbenchTemplateRid;
}
type WorkbenchTemplateRid = string;
interface WorkbenchTemplateShape {
    about: LocalizedTitleAndDescription;
}
/**
 * Creates a Workflow Builder Graph block.
 */
interface WorkflowBuilderGraphCreateBlockRequest {
    rid: string;
    versionId: string;
}
interface WorkflowBuilderGraphIdentifier_rid {
    type: "rid";
    rid: WorkflowBuilderRid;
}
type WorkflowBuilderGraphIdentifier = WorkflowBuilderGraphIdentifier_rid;
/**
 * Workflow Builder Graph shape that can be used to generate Workflow Builder Graphs.
 */
interface WorkflowBuilderGraphShape {
    about: LocalizedTitleAndDescription;
}
type WorkflowBuilderRid = string;
type WorkflowBuilderVersion = string;
/**
 * Creates a Workflow Lineage Graph block.
 */
interface WorkflowGraphCreateBlockRequest {
    rid: string;
    versionId?: string | null | undefined;
}
interface WorkflowGraphIdentifier {
    rid: string;
}
/**
 * Workflow Graph shape that can be used to generate Workflow Graphs. Never consumed by any downstream blocks.
 */
interface WorkflowGraphShape {
    about: LocalizedTitleAndDescription;
}
interface WorkshopApplicationCompassLocationShortcuts {
    compassFolderRid: string;
    displayNameOverride: string;
}
interface WorkshopApplicationInputShape {
    about: LocalizedTitleAndDescription;
}
interface WorkshopApplicationOutputShape {
    about: LocalizedTitleAndDescription;
}
interface WorkshopApplicationSaveLocation_compass {
    type: "compass";
    compass: WorkshopApplicationCompassLocationShortcuts;
}
type WorkshopApplicationSaveLocation = WorkshopApplicationSaveLocation_compass;
/**
 * An Input Shape use to provide a Workshop's Saved States SaveLocation
 */
interface WorkshopApplicationSaveLocationInputShape {
    about: LocalizedTitleAndDescription;
    id: StableShapeIdentifier;
}
interface WorkshopApplicationSaveLocationPartialResolvedShape {
    about: LocalizedTitleAndDescription;
    enableCompassLocationSelector: boolean;
    enableHomeFolderSaves: boolean;
    hideInaccessibleLocations: boolean;
    id: StableShapeIdentifier;
    saveLocations: Array<WorkshopApplicationSaveLocation>;
}
/**
 * Not yet implemented by the corresponding service
 */
interface WorkshopCreateBlockRequest {
    rid: string;
    version?: string | null | undefined;
}
interface WorkshopIdentifier_rid {
    type: "rid";
    rid: WorkshopRid;
}
type WorkshopIdentifier = WorkshopIdentifier_rid;
type WorkshopRid = string;
interface WritebackCreateBlockRequest {
    rid: string;
}
interface XlsxFormat {
}
/**
 * ZoneId should be formattable by the java.time.ZoneId.of(String)
 * Examples "America/New_York", "UTC", "UTC+5"
 */
type ZoneId = string;

export type { AbortedStatusV3, ActionLogRuleEditedObjectRelations, ActionLogRulePropertyValues, ActionLogRuleShape, ActionLogValue, ActionLogValue_actionRid, ActionLogValue_actionTimestamp, ActionLogValue_actionTypeRid, ActionLogValue_actionTypeVersion, ActionLogValue_actionUser, ActionLogValue_asynchronousWebhookInstanceIds, ActionLogValue_editedObjects, ActionLogValue_interfaceParameterPropertyValue, ActionLogValue_isReverted, ActionLogValue_notificationIds, ActionLogValue_notifiedUsers, ActionLogValue_objectParameterPropertyValue, ActionLogValue_parameterValue, ActionLogValue_revertTimestamp, ActionLogValue_revertUser, ActionLogValue_scenarioRid, ActionLogValue_summary, ActionLogValue_synchronousWebhookInstanceId, ActionParameterId, ActionParameterNotFound, ActionParameterRid, ActionParameterRidOrId, ActionParameterRidOrId_id, ActionParameterRidOrId_rid, ActionParameterShapeId, ActionParameterShapeTypeInterfaceTypeRidUnresolvable, ActionParameterShapeTypeObjectTypeIdUnresolvable, ActionParameterTypeShape, ActionParameterTypeShapeNotFound, ActionParameterTypeShapeTypeMismatch, ActionParameterTypeShapeTypeUnknown, ActionParameterV1MappingInfo, ActionTypeApiName, ActionTypeBlockSetRecommendation, ActionTypeIdentifier, ActionTypeIdentifier_rid, ActionTypeIdentifier_ridWithParameters, ActionTypeIdentifier_ridWithoutNestedParameters, ActionTypeLocator, ActionTypeNotFound, ActionTypeParameterIdentifier, ActionTypeParameterIdentifier_parameterAndAction, ActionTypeParameterIdentifiers, ActionTypeParameterNotFound, ActionTypeParameterReference, ActionTypeParameterShape, ActionTypeParameterShapeDisplayMetadata, ActionTypeRecommendation, ActionTypeReference, ActionTypeReferenceUnresolvable, ActionTypeRichTextComponent, ActionTypeRichTextComponent_message, ActionTypeRichTextComponent_parameter, ActionTypeRichTextComponent_parameterProperty, ActionTypeRid, ActionTypeRidWithParameters, ActionTypeShape, ActionTypeShapeDisplayMetadata, ActionTypeVersion, AddToDraftGroupRequest, AdditionalInputShapeResult, AdditionalOutputShapeResult, AipAgentCreateBlockRequest, AipAgentIdentifier, AipAgentIdentifier_ridAndVersion, AipAgentMajorVersion, AipAgentMinorVersion, AipAgentRid, AipAgentRidAndVersion, AipAgentShape, AipAgentVersion, AllPossibleVersionsMissingInputsConstraintFailure, AllPossibleVersionsMissingInputsConstraintFailureV2, AllowOntologySchemaMigrationsShape, AllowedObjectPropertyType, AllowedObjectPropertyType_objectPropertyType, AllowedProfileNamesConstraint, AndExpressionIdentifier, AnyInterfaceObjectSetRidType, AnyInterfaceReferenceListType, AnyInterfaceReferenceType, AnyObjectReferenceListType, AnyObjectReferenceType, AnyObjectSetRidType, AnySchema, AnyStructListType, AnyStructType, ApiNameResolver, ApolloAgentSecretType, ApolloArtifactUri, ApolloBlockSetPublishingStatus, ApolloBlockSetPublishingStatus_failure, ApolloBlockSetPublishingStatus_inProgress, ApolloBlockSetPublishingStatus_success, ApolloCrossStackManifest, ApolloEntityId, ApolloEnvironment, ApolloEnvironmentId, ApolloFoundrySpaceIdentifier, ApolloGranularConfig, ApolloHostUri, ApolloPlanId, ApolloPlanRid, ApolloPlanTaskRid, ApolloSecretAndKeyName, ApolloSecretName, ApolloSpaceId, ApolloSpaceIdentifiers, ApolloSpaceToPublishingStatus, ApolloStackLevelConfig, ApolloStackManagementConfig, ApolloStackManagementConfig_granularConfig, ApolloStackManagementConfig_stackLevelConfig, AppConfigCreateBlockRequest, AppConfigIdentifier, AppConfigIdentifier_rid, AppConfigOutputShape, AppConfigOutputSpecConfig, AppliedExternalRecommendationV2, ArrayBaseType, ArrayObjectPropertyType, ArtifactsPeerProducerProfileCreateBlockRequest, ArtifactsRepositoryIdentifier, ArtifactsRepositoryRid, ArtifactsRepositoryShape, AsCodeBlockSetMetadata, AssociatedBlockSetInstallation, AssociatedBlockSetInstallationIdentifiers, AssociatedBlockSetInstallation_existingBlockSet, AssociatedBlockSetInstallation_newBlockSet, AssociatedWithMultipleBlockSetInstallations, AttachResourceValidationErrors, AttachResourceValidationErrors_attachResourcesNotSupportedForBlockType, AttachResourcesNotSupportedForBlockType, AttachedOutputCreatedInAnotherInstallation, AttachedOutputShapeNotSpecified, AttachmentId, AttachmentListType, AttachmentMetadata, AttachmentType, AudioDecodeFormat, AudioDecodeFormat_flac, AudioDecodeFormat_mp2, AudioDecodeFormat_mp3, AudioDecodeFormat_mp4, AudioDecodeFormat_nistSphere, AudioDecodeFormat_ogg, AudioDecodeFormat_wav, AudioDecodeFormat_webm, AudioSchema, AuthoringLibraryIdentifier, AuthoringLibraryLocator, AuthoringLibraryLocator_condaLocator, AuthoringLibraryLocator_condaLocatorV2, AuthoringLibraryNotFoundError, AuthoringLibraryShape, AuthoringRepositoryCreateBlockRequest, AuthoringRepositoryCreateBlockRequestV2, AuthoringRepositoryEnvironmentIdentificationMethod, AuthoringRepositoryEnvironmentIdentificationMethodV2, AuthoringRepositoryEnvironmentIdentificationMethod_jobSpecs, AuthoringRepositoryIdentifier, AuthoringRepositoryOutputSpecConfig, AuthoringRepositoryReference, AuthoringRepositoryRid, AuthoringRepositoryShape, AuthoringRepositorySourceCodeConfig, AutomappedInput, AutomappingLevel, AutomappingLevel_childLevel, AutomappingLevel_topLevel, AutomationCreateBlockRequest, AutomationIdentifier, AutomationOutputSpecConfig, AutomationRid, AutomationShape, AutomationStatus, AutomationStatus_failedConstraints, AutomationStatus_idle, AutomationStatus_processing, AutomationStatus_upgrading, AutopilotWorkbenchCreateBlockRequest, AutopilotWorkbenchIdentifier, AutopilotWorkbenchRid, AutopilotWorkbenchShape, BaseParameterConstraintType, BaseParameterConstraintType_anyInterfaceObjectSetRid, BaseParameterConstraintType_anyInterfaceReference, BaseParameterConstraintType_anyInterfaceReferenceList, BaseParameterConstraintType_anyObjectReference, BaseParameterConstraintType_anyObjectReferenceList, BaseParameterConstraintType_anyObjectSetRid, BaseParameterConstraintType_anyStruct, BaseParameterConstraintType_anyStructList, BaseParameterConstraintType_attachment, BaseParameterConstraintType_attachmentList, BaseParameterConstraintType_boolean, BaseParameterConstraintType_booleanList, BaseParameterConstraintType_date, BaseParameterConstraintType_dateList, BaseParameterConstraintType_decimal, BaseParameterConstraintType_decimalList, BaseParameterConstraintType_double, BaseParameterConstraintType_doubleList, BaseParameterConstraintType_geohash, BaseParameterConstraintType_geohashList, BaseParameterConstraintType_geoshape, BaseParameterConstraintType_geoshapeList, BaseParameterConstraintType_geotimeSeriesReference, BaseParameterConstraintType_geotimeSeriesReferenceList, BaseParameterConstraintType_integer, BaseParameterConstraintType_integerList, BaseParameterConstraintType_interfaceObjectSetRid, BaseParameterConstraintType_interfaceReference, BaseParameterConstraintType_interfaceReferenceList, BaseParameterConstraintType_long, BaseParameterConstraintType_longList, BaseParameterConstraintType_marking, BaseParameterConstraintType_markingList, BaseParameterConstraintType_mediaReference, BaseParameterConstraintType_mediaReferenceList, BaseParameterConstraintType_objectReference, BaseParameterConstraintType_objectReferenceList, BaseParameterConstraintType_objectSetRid, BaseParameterConstraintType_objectTypeReference, BaseParameterConstraintType_scenarioReference, BaseParameterConstraintType_string, BaseParameterConstraintType_stringList, BaseParameterConstraintType_struct, BaseParameterConstraintType_structList, BaseParameterConstraintType_timeSeriesReference, BaseParameterConstraintType_timestamp, BaseParameterConstraintType_timestampList, BaseParameterType, BaseParameterType_attachment, BaseParameterType_attachmentList, BaseParameterType_boolean, BaseParameterType_booleanList, BaseParameterType_date, BaseParameterType_dateList, BaseParameterType_decimal, BaseParameterType_decimalList, BaseParameterType_double, BaseParameterType_doubleList, BaseParameterType_geohash, BaseParameterType_geohashList, BaseParameterType_geoshape, BaseParameterType_geoshapeList, BaseParameterType_geotimeSeriesReference, BaseParameterType_geotimeSeriesReferenceList, BaseParameterType_integer, BaseParameterType_integerList, BaseParameterType_interfaceObjectSetRid, BaseParameterType_interfaceReference, BaseParameterType_interfaceReferenceList, BaseParameterType_long, BaseParameterType_longList, BaseParameterType_marking, BaseParameterType_markingList, BaseParameterType_mediaReference, BaseParameterType_objectReference, BaseParameterType_objectReferenceList, BaseParameterType_objectSetRid, BaseParameterType_objectTypeReference, BaseParameterType_scenarioReference, BaseParameterType_string, BaseParameterType_stringList, BaseParameterType_struct, BaseParameterType_structList, BaseParameterType_timeSeriesReference, BaseParameterType_timestamp, BaseParameterType_timestampList, BaseType, BaseType_array, BaseType_primitive, BaseType_structV2, BatchEditBlockSetVersionError, BatchEditBlockSetVersionError_draftGroupNotEditable, BatchEditBlockSetVersionError_editPermissionDenied, BatchEditBlockSetVersionError_notFound, BatchEditBlockSetVersionError_notInEditableState, BatchEditBlockSetVersionError_ownedByOtherUser, BatchEditPermissionDeniedError, BatchGetApolloBlockSetVersionPublishingStatusRequest, BatchGetApolloBlockSetVersionPublishingStatusResponse, BatchGetBlockInstallationJobsRequest, BatchGetBlockInstallationJobsResponse, BatchGetBlockInstallationsRequest, BatchGetBlockInstallationsResponse, BatchGetBlockSetVersionStatusV3Request, BatchGetBlockSetVersionStatusV3Response, BatchGetInstallableBlockSetVersionsRequest, BatchGetInstallableBlockSetVersionsResponse, BatchGetInstallableBlockVersionRequest, BatchGetInstallableBlockVersionResponse, BatchGetPendingBlockSetVersionMetadataRequest, BatchGetPendingBlockSetVersionMetadataResponse, BatchOwnedByOtherUserError, BatchUpdatePendingBlockSetVersionMetadataRequestItemV3, BatchUpdatePendingBlockSetVersionMetadataRequestV3, BatchUpdatePendingBlockSetVersionMetadataResponseV3, BatchUpdatePendingInputShapeMetadataRequest, BatchUpdatePendingInputShapeMetadataResponse, BlobsterCreateBlockRequest, BlobsterInputIdentifier, BlobsterOutputIdentifier, BlobsterResourceInputShape, BlobsterResourceInputShapeTypeMismatch, BlobsterResourceOutputShape, BlobsterResourceShapeServiceMismatch, BlobsterResourceType, BlobsterRid, Block, BlockCreationError, BlockCreationErrorDataUploadFailed, BlockCreationErrorDataUploadTimeout, BlockCreationErrorGeneric, BlockCreationError_aborted, BlockCreationError_dataUploadFailed, BlockCreationError_dataUploadTimeout, BlockCreationError_generic, BlockDataId, BlockDisplayMetadata, BlockId, BlockIdAndType, BlockInputShapeSizeLimitCount, BlockInstallActionParameterTypeShapeError, BlockInstallActionParameterTypeShapeError_parameterNotFound, BlockInstallActionParameterTypeShapeError_requiredParameterMissing, BlockInstallActionParameterTypeShapeError_shapeNotFound, BlockInstallActionParameterTypeShapeError_shapeTypeInterfaceTypeRidUnresolvable, BlockInstallActionParameterTypeShapeError_shapeTypeMismatch, BlockInstallActionParameterTypeShapeError_shapeTypeObjectTypeIdUnresolvable, BlockInstallActionParameterTypeShapeError_shapeTypeUnknown, BlockInstallActionTypeParameterShapeErrorV2, BlockInstallActionTypeParameterShapeErrorV2_shapeTypeInterfaceTypeRidUnresolvable, BlockInstallActionTypeParameterShapeErrorV2_shapeTypeMismatch, BlockInstallActionTypeParameterShapeErrorV2_shapeTypeObjectTypeIdUnresolvable, BlockInstallActionTypeParameterShapeErrorV2_shapeTypeUnknown, BlockInstallBlobsterResourceShapeError, BlockInstallBlobsterResourceShapeError_serviceMismatch, BlockInstallBlobsterResourceShapeError_typeMismatch, BlockInstallColumnNotFound, BlockInstallColumnShapeError, BlockInstallColumnShapeError_datasourceReferenceMismatch, BlockInstallColumnShapeError_datasourceReferenceUnresolvable, BlockInstallColumnShapeError_missingColumnTypeClass, BlockInstallColumnShapeError_typeMismatch, BlockInstallCompassResourceInTrash, BlockInstallCompassResourceShapeError, BlockInstallCompassResourceShapeError_outputTypeMismatch, BlockInstallCompassResourceShapeError_typeMismatch, BlockInstallConnectionNotFoundError, BlockInstallConnectionReferenceMismatchError, BlockInstallConnectionReferenceUnresolvableError, BlockInstallError, BlockInstallError_buildFailure, BlockInstallError_buildOrchestrationFailure, BlockInstallError_buildTimeout, BlockInstallError_failedToDeleteResources, BlockInstallError_illegalRequestError, BlockInstallError_indexFailure, BlockInstallError_inputDependencyCycles, BlockInstallError_installFailure, BlockInstallError_installTimedOut, BlockInstallError_noProcessableInstallationInstructions, BlockInstallError_reconcileBlockInstallationResponseError, BlockInstallFailure, BlockInstallFlinkProfileNotFound, BlockInstallFunctionNotFound, BlockInstallFunctionShapeError, BlockInstallFunctionShapeErrorV2, BlockInstallFunctionShapeErrorV2_incompatibleSignature, BlockInstallFunctionShapeErrorV2_shapeConversion, BlockInstallFunctionShapeError_contractNotImplemented, BlockInstallFunctionShapeError_customTypeDataTypeActionTypeReferencesUnsupported, BlockInstallFunctionShapeError_customTypeDataTypeCustomTypeNotFound, BlockInstallFunctionShapeError_customTypeDataTypeInterfaceTypeUnresolvable, BlockInstallFunctionShapeError_customTypeDataTypeMarkingSubTypeUnknown, BlockInstallFunctionShapeError_customTypeDataTypeObjectTypeUnresolvable, BlockInstallFunctionShapeError_customTypeDataTypeUnknown, BlockInstallFunctionShapeError_dataTypeValueTypeUnresolvable, BlockInstallFunctionShapeError_dataTypeValueTypeUnresolvableV2, BlockInstallFunctionShapeError_doesNotSatisfyContractExpression, BlockInstallFunctionShapeError_incompatibleContractSemverBlocking, BlockInstallFunctionShapeError_incompatibleContractSemverNonBlocking, BlockInstallFunctionShapeError_inputDataTypeActionTypeReferencesUnsupported, BlockInstallFunctionShapeError_inputDataTypeActionTypeReferencesUnsupportedV2, BlockInstallFunctionShapeError_inputDataTypeCustomTypeNotFound, BlockInstallFunctionShapeError_inputDataTypeCustomTypeNotFoundV2, BlockInstallFunctionShapeError_inputDataTypeInterfaceTypeUnresolvable, BlockInstallFunctionShapeError_inputDataTypeMarkingSubTypeUnknown, BlockInstallFunctionShapeError_inputDataTypeMarkingSubTypeUnknownV2, BlockInstallFunctionShapeError_inputDataTypeMismatch, BlockInstallFunctionShapeError_inputDataTypeMismatchV2, BlockInstallFunctionShapeError_inputDataTypeObjectTypeUnresolvable, BlockInstallFunctionShapeError_inputDataTypeObjectTypeUnresolvableV2, BlockInstallFunctionShapeError_inputDataTypeUnknown, BlockInstallFunctionShapeError_inputDataTypeUnknownV2, BlockInstallFunctionShapeError_inputExtraDataTypeUnknown, BlockInstallFunctionShapeError_inputNamesDiffer, BlockInstallFunctionShapeError_inputNotFound, BlockInstallFunctionShapeError_inputNotFoundV2, BlockInstallFunctionShapeError_inputNotOptional, BlockInstallFunctionShapeError_inputNotOptionalV2, BlockInstallFunctionShapeError_outputDataTypeActionTypeReferencesUnsupported, BlockInstallFunctionShapeError_outputDataTypeCustomTypeNotFound, BlockInstallFunctionShapeError_outputDataTypeInterfaceTypeUnresolvable, BlockInstallFunctionShapeError_outputDataTypeMarkingSubTypeUnknown, BlockInstallFunctionShapeError_outputDataTypeMismatch, BlockInstallFunctionShapeError_outputDataTypeObjectTypeUnresolvable, BlockInstallFunctionShapeError_outputDataTypeUnknown, BlockInstallFunctionShapeError_outputTypeMismatch, BlockInstallFunctionShapeError_outputTypeUnknown, BlockInstallFunctionShapeError_unexpectedNonOptionalInput, BlockInstallFunctionShapeError_unexpectedNonOptionalInputV2, BlockInstallInputActionTypeNotFound, BlockInstallInputDependencyCycles, BlockInstallInputParameterTypeMismatch, BlockInstallInputShapeNotSpecified, BlockInstallInputShapeNotSpecified_requiredInputShape, BlockInstallInputShapeNotSpecified_usedByInputGroup, BlockInstallInputShapeTypeMismatch, BlockInstallInputShapeUsedByInputGroup, BlockInstallInterfaceActionTypeConstraintMissingParameterConstraints, BlockInstallInterfaceActionTypeConstraintNotFound, BlockInstallInterfaceActionTypeConstraintShapeError, BlockInstallInterfaceActionTypeConstraintShapeError_interfaceActionTypeConstraintRequiredMismatch, BlockInstallInterfaceActionTypeConstraintShapeError_interfaceTypeReferenceMismatch, BlockInstallInterfaceActionTypeConstraintShapeError_interfaceTypeReferenceUnresolvable, BlockInstallInterfaceLinkTypeNotFound, BlockInstallInterfaceLinkTypeShapeError, BlockInstallInterfaceLinkTypeShapeError_expectedLinkedInterfaceButWasObject, BlockInstallInterfaceLinkTypeShapeError_expectedLinkedObjectButWasInterface, BlockInstallInterfaceLinkTypeShapeError_interfaceLinkTypeCardinalityMismatch, BlockInstallInterfaceLinkTypeShapeError_interfaceLinkTypeRequiredMismatch, BlockInstallInterfaceLinkTypeShapeError_interfaceTypeReferenceMismatch, BlockInstallInterfaceLinkTypeShapeError_interfaceTypeReferenceUnresolvable, BlockInstallInterfaceLinkTypeShapeError_linkedInterfaceTypeReferenceMismatch, BlockInstallInterfaceLinkTypeShapeError_linkedInterfaceTypeReferenceUnresolvable, BlockInstallInterfaceLinkTypeShapeError_linkedObjectTypeReferenceMismatch, BlockInstallInterfaceLinkTypeShapeError_linkedObjectTypeReferenceUnresolvable, BlockInstallInterfaceParameterConstraintNotFound, BlockInstallInterfaceParameterConstraintShapeError, BlockInstallInterfaceParameterConstraintShapeError_actionTypeConstraintReferenceMismatch, BlockInstallInterfaceParameterConstraintShapeError_actionTypeConstraintReferenceUnresolvable, BlockInstallInterfaceParameterConstraintShapeError_interfaceParameterConstraintRequiredMismatch, BlockInstallInterfaceParameterConstraintShapeError_interfaceParameterConstraintTypeMismatch, BlockInstallInterfacePropertyTypeNotFound, BlockInstallInterfacePropertyTypeShapeError, BlockInstallInterfacePropertyTypeShapeError_interfacePropertyTypeRequireImplementationMismatch, BlockInstallInterfacePropertyTypeShapeError_interfaceTypeReferenceMismatch, BlockInstallInterfacePropertyTypeShapeError_interfaceTypeReferenceUnresolvable, BlockInstallInterfacePropertyTypeShapeError_nestedArraysUnsupported, BlockInstallInterfacePropertyTypeShapeError_nestedTypeUnknown, BlockInstallInterfacePropertyTypeShapeError_plainTextTypeUnsupported, BlockInstallInterfacePropertyTypeShapeError_sharedPropertyTypeReferenceMismatch, BlockInstallInterfacePropertyTypeShapeError_structFieldTypeUnsupported, BlockInstallInterfacePropertyTypeShapeError_typeMismatch, BlockInstallInterfacePropertyTypeShapeError_typeUnknown, BlockInstallInterfacePropertyTypeShapeError_typeUnsupported, BlockInstallInterfaceTypeMissingActionTypeConstraints, BlockInstallInterfaceTypeMissingExtendedInterfaces, BlockInstallInterfaceTypeMissingLinks, BlockInstallInterfaceTypeMissingProperties, BlockInstallInterfaceTypeNotFound, BlockInstallLinkTypeNotFound, BlockInstallLinkTypeShapeError, BlockInstallLinkTypeShapeError_backendIncompatible, BlockInstallLinkTypeShapeError_editsSupportIncompatible, BlockInstallLinkTypeShapeError_intermediaryLinkLinkTypeMismatch, BlockInstallLinkTypeShapeError_intermediaryLinkLinkTypeUnresolvable, BlockInstallLinkTypeShapeError_intermediaryLinkObjectTypeMismatch, BlockInstallLinkTypeShapeError_intermediaryLinkObjectTypeUnresolvable, BlockInstallLinkTypeShapeError_linkTypeUnknown, BlockInstallLinkTypeShapeError_manyToManyLinkObjectTypeAMismatch, BlockInstallLinkTypeShapeError_manyToManyLinkObjectTypeAUnresolvable, BlockInstallLinkTypeShapeError_manyToManyLinkObjectTypeBMismatch, BlockInstallLinkTypeShapeError_manyToManyLinkObjectTypeBUnresolvable, BlockInstallLinkTypeShapeError_objectsBackendUnknown, BlockInstallLinkTypeShapeError_oneToManyLinkManySideObjectTypeMismatch, BlockInstallLinkTypeShapeError_oneToManyLinkManySideObjectTypeUnresolvable, BlockInstallLinkTypeShapeError_oneToManyLinkOneSideObjectTypeMismatch, BlockInstallLinkTypeShapeError_oneToManyLinkOneSideObjectTypeUnresolvable, BlockInstallLinkTypeShapeError_outputBackendMismatch, BlockInstallLinkTypeShapeError_outputEditsSupportMismatch, BlockInstallLinkTypeShapeError_resolvedIntermediaryLinkOntologyTypesInconsistent, BlockInstallLinkTypeShapeError_resolvedLinkedObjectTypesUnknown, BlockInstallLinkTypeShapeError_resolvedManyToManyLinkObjectTypesInconsistent, BlockInstallLinkTypeShapeError_resolvedOneToManyLinkObjectTypesInconsistent, BlockInstallLinkTypeShapeError_unexpectedLink, BlockInstallLinkTypeShapeError_unexpectedLinkedOntologyTypes, BlockInstallLinkTypeShapeError_unexpectedManyToManyLink, BlockInstallLinkTypeShapeError_unexpectedOneToManyLink, BlockInstallLinkTypeShapeError_unexpectedResolvedManyToManyLinkObjectTypes, BlockInstallLinkTypeShapeError_unexpectedResolvedOneToManyLinkObjectTypes, BlockInstallLocation, BlockInstallLocationClassificationConstraintsNotSatisfied, BlockInstallMagritteConnectionTypeMismatchError, BlockInstallMagritteConnectionTypeUnsupported, BlockInstallMagritteSourceApiNameMismatch, BlockInstallMagritteSourceMissingRequiredSecrets, BlockInstallMagritteSourceMissingRequiredUsageRestrictions, BlockInstallMagritteSourceNotFound, BlockInstallMagritteSourceTypeMismatch, BlockInstallMediaSetIncompatiblePathPolicy, BlockInstallMediaSetIncompatibleSchema, BlockInstallMediaSetIncompatibleSchemaV2, BlockInstallMediaSetIncompatibleTransactionPolicy, BlockInstallMediaSetNotSupported, BlockInstallModelShapeError, BlockInstallModelShapeError_modelTypeMismatch, BlockInstallModelShapeError_modelTypeMismatchV2, BlockInstallModelShapeError_modelTypeMismatchV3, BlockInstallModelShapeError_ridTypeMismatch, BlockInstallModelShapeError_serviceMismatch, BlockInstallNotepadTemplateNotFound, BlockInstallNotepadTemplateParameterNotFound, BlockInstallNotepadTemplateParameterShapeError, BlockInstallNotepadTemplateParameterShapeError_parameterTypeMismatch, BlockInstallObjectTypeForObjectViewNotFound, BlockInstallObjectTypeNotFound, BlockInstallObjectTypeShapeError, BlockInstallObjectTypeShapeError_backendIncompatible, BlockInstallObjectTypeShapeError_editsSupportIncompatible, BlockInstallObjectTypeShapeError_objectsBackendUnknown, BlockInstallObjectTypeShapeError_outputBackendMismatch, BlockInstallObjectTypeShapeError_outputEditsSupportMismatch, BlockInstallOutputShapeTypeMismatch, BlockInstallPrefixShapeError, BlockInstallPrefixShapeError_inconsistentPrefix, BlockInstallPrefixShapeError_prefixInvalid, BlockInstallPropertyTypeNotFound, BlockInstallPropertyTypeShapeError, BlockInstallPropertyTypeShapeError_inlineActionTypeMissing, BlockInstallPropertyTypeShapeError_inlineActionTypeReferenceMismatch, BlockInstallPropertyTypeShapeError_inlineActionTypeReferenceUnresolvable, BlockInstallPropertyTypeShapeError_nestedArraysUnsupported, BlockInstallPropertyTypeShapeError_nestedTypeUnknown, BlockInstallPropertyTypeShapeError_objectTypeReferenceMismatch, BlockInstallPropertyTypeShapeError_objectTypeReferenceUnresolvable, BlockInstallPropertyTypeShapeError_plainTextTypeUnsupported, BlockInstallPropertyTypeShapeError_sharedPropertyTypeMissing, BlockInstallPropertyTypeShapeError_sharedPropertyTypeReferenceMismatch, BlockInstallPropertyTypeShapeError_sharedPropertyTypeReferenceUnresolvable, BlockInstallPropertyTypeShapeError_structFieldTypeUnsupported, BlockInstallPropertyTypeShapeError_typeMismatch, BlockInstallPropertyTypeShapeError_typeUnknown, BlockInstallPropertyTypeShapeError_typeUnsupported, BlockInstallPropertyTypeShapeError_vectorTypeMismatchNonBlocking, BlockInstallReconcileError, BlockInstallResourceNotChildOfTargetCompassFolder, BlockInstallResourceNotFound, BlockInstallSharedPropertyTypeNotFound, BlockInstallSharedPropertyTypeShapeError, BlockInstallSharedPropertyTypeShapeError_nestedArraysUnsupported, BlockInstallSharedPropertyTypeShapeError_nestedTypeUnknown, BlockInstallSharedPropertyTypeShapeError_plainTextTypeUnsupported, BlockInstallSharedPropertyTypeShapeError_structFieldTypeUnsupported, BlockInstallSharedPropertyTypeShapeError_typeMismatch, BlockInstallSharedPropertyTypeShapeError_typeUnknown, BlockInstallSharedPropertyTypeShapeError_typeUnsupported, BlockInstallStringParameterMaxLengthExceeded, BlockInstallTabularDatasourceShapeError, BlockInstallTabularDatasourceShapeError_typeNotSupported, BlockInstallTabularDatasourceShapeError_typeUnknown, BlockInstallation, BlockInstallationContext, BlockInstallationFailure, BlockInstallationFailureV2, BlockInstallationId, BlockInstallationJob, BlockInstallationOutputReference, BlockInstallationResolvedInput, BlockInstallationResolvedOutput, BlockInstallationRid, BlockInternal, BlockInternalId, BlockInternal_blockV1, BlockManifestV1, BlockRecommendation, BlockRecommendationId, BlockReference, BlockReference_existingBlock, BlockReference_newBlock, BlockSet, BlockSetBlockInstanceId, BlockSetCategorizedTags, BlockSetCompassInstallLocation, BlockSetCreationAbortError, BlockSetCreationAbortReason, BlockSetCreationAbortReason_error, BlockSetCreationAbortReason_userRequested, BlockSetDocumentation, BlockSetDuplicateOutputShapesError, BlockSetExternalServiceError, BlockSetId, BlockSetInputActionTypeParameterReference, BlockSetInputBlockShapeReference, BlockSetInputGroup, BlockSetInputGroupId, BlockSetInputGroups, BlockSetInputShape, BlockSetInputShapeAdded, BlockSetInputShapeDiff, BlockSetInputShapeDiffSeverity, BlockSetInputShapeDiffType, BlockSetInputShapeDiffType_inputShapeAdded, BlockSetInputShapeDiffType_inputShapeModified, BlockSetInputShapeDiffType_inputShapeRemoved, BlockSetInputShapeModified, BlockSetInputShapeOld, BlockSetInputShapeReference, BlockSetInputShapeReferencingOutputShapeV2, BlockSetInputShapeRemoved, BlockSetInputShapeSizeLimitCount, BlockSetInputShapeWithBackingShapes, BlockSetInputShapes, BlockSetInputShapesNotMergeableError, BlockSetInputVersionSkew, BlockSetInputsAccessedInPreallocateCycle, BlockSetInputsAccessedInReconcileCycleV2, BlockSetInstallLocation, BlockSetInstallValidationError, BlockSetInstallValidationErrorDetail, BlockSetInstallValidationErrorDetailV2, BlockSetInstallValidationErrorDetailV2_blockSetInstallationDoesNotExist, BlockSetInstallValidationErrorDetailV2_blockSetVersionRecalled, BlockSetInstallValidationErrorDetailV2_externalServiceError, BlockSetInstallValidationErrorDetailV2_incompatibleLinkedProduct, BlockSetInstallValidationErrorDetailV2_installingBlockSetsFromMultipleStores, BlockSetInstallValidationErrorDetailV2_integrationValidationError, BlockSetInstallValidationErrorDetailV2_invalidDefaultInstallationBuildOptionsNotOverridden, BlockSetInstallValidationErrorDetailV2_invalidLinkedProduct, BlockSetInstallValidationErrorDetailV2_missingCbacMarkingConstraint, BlockSetInstallValidationErrorDetailV2_multipleBlockSetsInstalledIntoSameProject, BlockSetInstallValidationErrorDetailV2_newInstallationOfASingletonBlockSetThatIsAlreadyInstalled, BlockSetInstallValidationErrorDetailV2_notAllInstallationsInSameOntology, BlockSetInstallValidationErrorDetailV2_ontologyInstallLocationNotDefined, BlockSetInstallValidationErrorDetailV2_ontologyPackageInDefaultOntologyNotAllowed, BlockSetInstallValidationErrorDetailV2_resourceUsedAsBothInputAndOutput, BlockSetInstallValidationErrorDetailV2_serializable, BlockSetInstallValidationErrorDetailV2_targetOntologyIsNotLinkedToTargetNamespace, BlockSetInstallValidationErrorDetailV2_unknownError, BlockSetInstallValidationErrorDetailV2_upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes, BlockSetInstallValidationErrorDetail_blockSetInstallationDoesNotExist, BlockSetInstallValidationErrorDetail_blockSetVersionRecalled, BlockSetInstallValidationErrorDetail_duplicateBlockReference, BlockSetInstallValidationErrorDetail_invalidBlockReference, BlockSetInstallValidationErrorDetail_invalidDefaultInstallationBuildOptionsNotOverridden, BlockSetInstallValidationErrorDetail_invalidInstallationProject, BlockSetInstallValidationErrorDetail_missingCbacMarkingConstraint, BlockSetInstallValidationErrorDetail_multipleBlockSetInstallsWithSameKey, BlockSetInstallValidationErrorDetail_newInstallationOfASingletonBlockSetThatIsAlreadyInstalled, BlockSetInstallValidationErrorDetail_ontologyPackageInDefaultOntologyNotAllowed, BlockSetInstallValidationErrorDetail_serializable, BlockSetInstallValidationErrorDetail_targetInstallLocationDoesNotMatchCurrentLocation, BlockSetInstallValidationErrorDetail_targetOntologyIsNotLinkedToTargetNamespace, BlockSetInstallValidationErrorDetail_unknownError, BlockSetInstallValidationErrorDetail_upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes, BlockSetInstallValidationErrorV2, BlockSetInstallationAccessDisallowedRationale, BlockSetInstallationAccessDisallowedRationale_blockSetNotFound, BlockSetInstallationAccessDisallowedRationale_blockSetVersionNotFound, BlockSetInstallationAccessDisallowedRationale_editBlockSetInstallationsPermissionDenied, BlockSetInstallationAccessDisallowedRationale_installBlockSetPermissionDenied, BlockSetInstallationAccessDisallowedRationale_installFromMarketplacePermissionDenied, BlockSetInstallationAccessDisallowedRationale_installInOntologyPermissionDenied, BlockSetInstallationAccessDisallowedRationale_localMarketplaceNotFound, BlockSetInstallationAccessDisallowedRationale_notAuthorizedToDeclassify, BlockSetInstallationAccessDisallowedRationale_notAuthorizedToUseMarkings, BlockSetInstallationAccessDisallowedRationale_partiallyDeletedInstallation, BlockSetInstallationCapabilities, BlockSetInstallationDisplayMetadata, BlockSetInstallationDoesNotExist, BlockSetInstallationHint, BlockSetInstallationHintId, BlockSetInstallationHints, BlockSetInstallationHintsV1, BlockSetInstallationHints_v1, BlockSetInstallationImmutability, BlockSetInstallationJob, BlockSetInstallationJobAssociatedInstallation, BlockSetInstallationJobCapabilities, BlockSetInstallationJobError, BlockSetInstallationJobMetadata, BlockSetInstallationJobRid, BlockSetInstallationJobStatus, BlockSetInstallationJobStatusBuilding, BlockSetInstallationJobStatusError, BlockSetInstallationJobStatusInProgress, BlockSetInstallationJobStatusSuccess, BlockSetInstallationJobStatus_building, BlockSetInstallationJobStatus_error, BlockSetInstallationJobStatus_inProgress, BlockSetInstallationJobStatus_success, BlockSetInstallationMetadata, BlockSetInstallationOutputReference, BlockSetInstallationResolvedEntities, BlockSetInstallationResolvedInput, BlockSetInstallationResolvedInputSource, BlockSetInstallationResolvedInputSourceV2, BlockSetInstallationResolvedInputSourceV2_externallyRecommendedOutput, BlockSetInstallationResolvedInputSourceV2_fromDefault, BlockSetInstallationResolvedInputSourceV2_manuallyProvided, BlockSetInstallationResolvedInputSourceV3, BlockSetInstallationResolvedInputSourceV3_automapped, BlockSetInstallationResolvedInputSourceV3_externallyRecommendedOutput, BlockSetInstallationResolvedInputSourceV3_fromDefault, BlockSetInstallationResolvedInputSourceV3_manuallyProvided, BlockSetInstallationResolvedInputSource_externallyRecommendedOutput, BlockSetInstallationResolvedInputSource_fromDefault, BlockSetInstallationResolvedInputSource_manuallyProvided, BlockSetInstallationResolvedInputV2, BlockSetInstallationResolvedInputV3, BlockSetInstallationResolvedShapes, BlockSetInstallationRid, BlockSetInstallationTargetState, BlockSetInstallationV2, BlockSetIntegrationValidationError, BlockSetInternalId, BlockSetInternalRecommendation, BlockSetInternalRecommendationVersionSkew, BlockSetManifestV1, BlockSetNamedVersion, BlockSetNotFoundRationale, BlockSetOutputReference, BlockSetOutputShape, BlockSetOutputShapeAdded, BlockSetOutputShapeDiff, BlockSetOutputShapeDiffSeverity, BlockSetOutputShapeDiffType, BlockSetOutputShapeDiffType_outputShapeAdded, BlockSetOutputShapeDiffType_outputShapeModified, BlockSetOutputShapeDiffType_outputShapeRemoved, BlockSetOutputShapeMetadata, BlockSetOutputShapeModified, BlockSetOutputShapeOld, BlockSetOutputShapeReference, BlockSetOutputShapeRemoved, BlockSetOutputShapeSizeLimitCount, BlockSetOutputShapeWithBackingShape, BlockSetOutputShapes, BlockSetProductGroupMember, BlockSetProductGroupMemberVersionPolicy, BlockSetProductGroupMemberVersionPolicy_latest, BlockSetProductGroupMemberVersionPolicy_pinnedVersion, BlockSetProductGroupMemberVersionPolicy_releaseChannel, BlockSetPublishingJobFailure, BlockSetPublishingJobInProgress, BlockSetPublishingJobRid, BlockSetPublishingJobSuccess, BlockSetRecommendationBody, BlockSetRecommendationBody_actionType, BlockSetRecommendationBody_simple, BlockSetRecommendationId, BlockSetRecommendationVariant, BlockSetReference, BlockSetReference_existingBlockSet, BlockSetReference_newBlockSet, BlockSetSecurityRid, BlockSetShape, BlockSetShapeDependencies, BlockSetShapeDependency, BlockSetShapeDiffCounts, BlockSetShapeId, BlockSetShapeInternal, BlockSetShapeInternal_input, BlockSetShapeInternal_output, BlockSetShapeMappingInfo, BlockSetShapeVisibility, BlockSetShapeVisibility_invisible, BlockSetShapeVisibility_visible, BlockSetShapesRemovalError, BlockSetSizeLimitThresholdReached, BlockSetTag, BlockSetTagCategory, BlockSetTags, BlockSetTotalShapeSizeLimitCount, BlockSetUpdatedEventKeyV2, BlockSetVersion, BlockSetVersionDiff, BlockSetVersionDiffFromEmptyRequest, BlockSetVersionDiffRequest, BlockSetVersionDiffSummary, BlockSetVersionEmptyOutputSpecsError, BlockSetVersionEmptyTitleError, BlockSetVersionErrorRecovery, BlockSetVersionErrorRecovery_finalizing, BlockSetVersionErrorRecovery_idle, BlockSetVersionErrorRecovery_materializing, BlockSetVersionFinalizingError, BlockSetVersionId, BlockSetVersionIdleError, BlockSetVersionMatcher, BlockSetVersionMaterializingError, BlockSetVersionMissingInputsConstraintFailure, BlockSetVersionMissingInputsConstraintFailureV2, BlockSetVersionNotFoundRationale, BlockSetVersionRange, BlockSetVersionRecalled, BlockSetVersionReference, BlockSetVersionReleaseMetadata, BlockSetVersionStatusResponse, BlockSetVersionStatusResponse_aborted, BlockSetVersionStatusResponse_finalized, BlockSetVersionStatusResponse_finalizing, BlockSetVersionStatusResponse_idle, BlockSetVersionStatusResponse_initializing, BlockSetVersionStatusResponse_materializing, BlockSetVersionStatusV3, BlockSetVersionStatusV3_aborted, BlockSetVersionStatusV3_finalized, BlockSetVersionStatusV3_finalizing, BlockSetVersionStatusV3_idle, BlockSetVersionStatusV3_initializing, BlockSetVersionStatusV3_processing, BlockSetVersionStatusV3_uploading, BlockSetVersionValidationError, BlockSetVersionValidationErrorDetail, BlockSetVersionValidationErrorDetail_blockTypesNotGenerallyAvailableForTargetEnvironment, BlockSetVersionValidationErrorDetail_duplicateOutputShapes, BlockSetVersionValidationErrorDetail_emptyOutputSpecs, BlockSetVersionValidationErrorDetail_emptyTitle, BlockSetVersionValidationErrorDetail_folderInputPreventsInstallingInNewProject, BlockSetVersionValidationErrorDetail_indistinguishableInputShapes, BlockSetVersionValidationErrorDetail_inputShapeInvalidReference, BlockSetVersionValidationErrorDetail_inputShapeVersionSkew, BlockSetVersionValidationErrorDetail_inputShapesNotMergeable, BlockSetVersionValidationErrorDetail_inputsAccessedInPreallocateCycle, BlockSetVersionValidationErrorDetail_inputsAccessedInReconcileCycle, BlockSetVersionValidationErrorDetail_internalRecommendationVersionSkew, BlockSetVersionValidationErrorDetail_missingInternalRecommendation, BlockSetVersionValidationErrorDetail_sizeLimitThresholdReachedV3, BlockSetVersionValidationErrorDetail_strictFolderTrackingInvalidDiscoverySpec, BlockSetVersionValidationErrorDetail_strictFolderTrackingInvalidProvenance, BlockSetVersionValidationErrorDetail_strictFolderTrackingMultipleDiscoverySpecs, BlockSetVersionValidationErrorDetail_strictFolderTrackingNoDiscoverySpec, BlockShape, BlockShapeBuildMetadata, BlockShapeBuildMetadata_shapeJobSpecsBuildMetadata, BlockShapeId, BlockShape_input, BlockShape_output, BlockShapesMappingInfo, BlockSizeLimitCount, BlockSpecificConfiguration, BlockSpecificConfiguration_aipAgent, BlockSpecificConfiguration_appConfigAppBar, BlockSpecificConfiguration_appConfigAuthorizationChooserPresets, BlockSpecificConfiguration_appConfigAuthorizationChooserRules, BlockSpecificConfiguration_appConfigCosmos, BlockSpecificConfiguration_appConfigGaia, BlockSpecificConfiguration_appConfigTitanium, BlockSpecificConfiguration_artifactsPeerProducerProfile, BlockSpecificConfiguration_authoringRepository, BlockSpecificConfiguration_automation, BlockSpecificConfiguration_autopilotWorkbench, BlockSpecificConfiguration_blobster, BlockSpecificConfiguration_carbon, BlockSpecificConfiguration_checkpointConfig, BlockSpecificConfiguration_cipherChannel, BlockSpecificConfiguration_cipherLicense, BlockSpecificConfiguration_codeWorkspace, BlockSpecificConfiguration_compass, BlockSpecificConfiguration_contour, BlockSpecificConfiguration_dataHealth, BlockSpecificConfiguration_deployedApp, BlockSpecificConfiguration_directDatasource, BlockSpecificConfiguration_eddieEdgePipeline, BlockSpecificConfiguration_eddieGroup, BlockSpecificConfiguration_editsView, BlockSpecificConfiguration_evaluationSuite, BlockSpecificConfiguration_foundryPeerProducerProfile, BlockSpecificConfiguration_functionConfigurations, BlockSpecificConfiguration_functionPackageConfiguration, BlockSpecificConfiguration_functions, BlockSpecificConfiguration_logic, BlockSpecificConfiguration_machinery, BlockSpecificConfiguration_magritteConnector, BlockSpecificConfiguration_magritteExport, BlockSpecificConfiguration_magritteSource, BlockSpecificConfiguration_mapRenderingService, BlockSpecificConfiguration_mediaSet, BlockSpecificConfiguration_model, BlockSpecificConfiguration_modelStudio, BlockSpecificConfiguration_monitoringView, BlockSpecificConfiguration_namedCredential, BlockSpecificConfiguration_networkEgressPolicy, BlockSpecificConfiguration_notepad, BlockSpecificConfiguration_objectSet, BlockSpecificConfiguration_objectView, BlockSpecificConfiguration_ontology, BlockSpecificConfiguration_ontologySdk, BlockSpecificConfiguration_peerProfile, BlockSpecificConfiguration_podModel, BlockSpecificConfiguration_quiver, BlockSpecificConfiguration_resourceUpdates, BlockSpecificConfiguration_restrictedView, BlockSpecificConfiguration_rosetta, BlockSpecificConfiguration_satelliteImageryModel, BlockSpecificConfiguration_savedSearchAroundV2, BlockSpecificConfiguration_schedule, BlockSpecificConfiguration_slate, BlockSpecificConfiguration_solutionDesign, BlockSpecificConfiguration_sqlWorksheet, BlockSpecificConfiguration_staticDataset, BlockSpecificConfiguration_storedProcedure, BlockSpecificConfiguration_streamDataset, BlockSpecificConfiguration_taurusWorkflow, BlockSpecificConfiguration_templates, BlockSpecificConfiguration_thirdPartyApplication, BlockSpecificConfiguration_timeSeriesSync, BlockSpecificConfiguration_transforms, BlockSpecificConfiguration_valueType, BlockSpecificConfiguration_versionedObjectSet, BlockSpecificConfiguration_vertex, BlockSpecificConfiguration_virtualTable, BlockSpecificConfiguration_vortex, BlockSpecificConfiguration_walkthrough, BlockSpecificConfiguration_webhooks, BlockSpecificConfiguration_widgetSet, BlockSpecificConfiguration_workbenchTemplate, BlockSpecificConfiguration_workflowBuilderGraph, BlockSpecificConfiguration_workflowGraph, BlockSpecificConfiguration_workshop, BlockSpecificConfiguration_writeback, BlockSpecificCreateRequest, BlockSpecificCreateRequest_aipAgent, BlockSpecificCreateRequest_appConfigAppBar, BlockSpecificCreateRequest_appConfigAuthorizationChooserPresets, BlockSpecificCreateRequest_appConfigAuthorizationChooserRules, BlockSpecificCreateRequest_appConfigCosmos, BlockSpecificCreateRequest_appConfigGaia, BlockSpecificCreateRequest_appConfigTitanium, BlockSpecificCreateRequest_artifactsPeerProducerProfile, BlockSpecificCreateRequest_authoringRepository, BlockSpecificCreateRequest_authoringRepositoryV2, BlockSpecificCreateRequest_automation, BlockSpecificCreateRequest_autopilotWorkbench, BlockSpecificCreateRequest_blobster, BlockSpecificCreateRequest_carbon, BlockSpecificCreateRequest_checkpointConfig, BlockSpecificCreateRequest_cipherChannel, BlockSpecificCreateRequest_cipherLicense, BlockSpecificCreateRequest_codeWorkspace, BlockSpecificCreateRequest_compass, BlockSpecificCreateRequest_contour, BlockSpecificCreateRequest_dataHealth, BlockSpecificCreateRequest_deployedApp, BlockSpecificCreateRequest_directDatasource, BlockSpecificCreateRequest_eddie, BlockSpecificCreateRequest_eddieEdgePipeline, BlockSpecificCreateRequest_editsView, BlockSpecificCreateRequest_evaluationSuite, BlockSpecificCreateRequest_foundryPeerProducerProfile, BlockSpecificCreateRequest_functionConfigurations, BlockSpecificCreateRequest_functionPackageConfiguration, BlockSpecificCreateRequest_functions, BlockSpecificCreateRequest_logic, BlockSpecificCreateRequest_machinery, BlockSpecificCreateRequest_magritteConnector, BlockSpecificCreateRequest_magritteExport, BlockSpecificCreateRequest_magritteSource, BlockSpecificCreateRequest_mapRenderingService, BlockSpecificCreateRequest_mediaSet, BlockSpecificCreateRequest_model, BlockSpecificCreateRequest_modelStudio, BlockSpecificCreateRequest_monitoringView, BlockSpecificCreateRequest_namedCredential, BlockSpecificCreateRequest_networkEgressPolicy, BlockSpecificCreateRequest_notepad, BlockSpecificCreateRequest_notepadTemplate, BlockSpecificCreateRequest_objectSet, BlockSpecificCreateRequest_objectView, BlockSpecificCreateRequest_ontology, BlockSpecificCreateRequest_ontologySdk, BlockSpecificCreateRequest_ontologySdkV2, BlockSpecificCreateRequest_peerProfile, BlockSpecificCreateRequest_quiver, BlockSpecificCreateRequest_resourceUpdates, BlockSpecificCreateRequest_restrictedView, BlockSpecificCreateRequest_rosetta, BlockSpecificCreateRequest_satelliteImageryModel, BlockSpecificCreateRequest_savedSearchAroundV2, BlockSpecificCreateRequest_schedule, BlockSpecificCreateRequest_slate, BlockSpecificCreateRequest_solutionDesign, BlockSpecificCreateRequest_sqlWorksheet, BlockSpecificCreateRequest_staticDataset, BlockSpecificCreateRequest_storedProcedure, BlockSpecificCreateRequest_streamDataset, BlockSpecificCreateRequest_taurus, BlockSpecificCreateRequest_templates, BlockSpecificCreateRequest_thirdPartyApplication, BlockSpecificCreateRequest_timeSeriesSync, BlockSpecificCreateRequest_transforms, BlockSpecificCreateRequest_valueType, BlockSpecificCreateRequest_versionedObjectSet, BlockSpecificCreateRequest_vertex, BlockSpecificCreateRequest_virtualTable, BlockSpecificCreateRequest_vortex, BlockSpecificCreateRequest_walkthrough, BlockSpecificCreateRequest_webhooks, BlockSpecificCreateRequest_widgetSet, BlockSpecificCreateRequest_workbenchTemplate, BlockSpecificCreateRequest_workflowBuilderGraph, BlockSpecificCreateRequest_workflowGraph, BlockSpecificCreateRequest_workshop, BlockSpecificCreateRequest_writeback, BlockType, BlockTypesNotGenerallyAvailableForTargetEnvironment, BlockV1, BlockVersion, BlockVersionCreationErrorStatus, BlockVersionCreationPendingStatus, BlockVersionCreationPendingStatus_waitingForData, BlockVersionCreationPendingStatus_waitingForFinalization, BlockVersionCreationStatus, BlockVersionCreationStatus_error, BlockVersionCreationStatus_pending, BlockVersionCreationStatus_success, BlockVersionId, BlockVersionIdDoesNotExist, BlockVersionMatcher, BlockVersionRange, BmpFormat, BooleanListType, BooleanType, BooleanValue, Branch, BuildCancelled, BuildError, BuildFailure, BuildJobIds, BuildOrchestrationFailure, BuildRid, BuildSettings, BuildTimedOut, BuildTimeout, BuildToolOrigin, BuildingInstallPendingStatus, BuildsAndIndexingIds, BuildsFinishedAtTimestamp, BulkCreateBlockSetVersionRequest, BulkCreateBlockSetVersionResponse, BulkImportBlockSetsDetailsFailure, BulkImportBlockSetsDetailsSuccess, BulkImportBlockSetsResponse, BulkImportBlockSetsResponseV2, BulkImportBlockSetsResponseV2_invalidProductPermissions, BulkImportBlockSetsResponseV2_malformedFile, BulkImportBlockSetsResponseV2_publicKeyNotRecognized, BulkImportBlockSetsResponseV2_success, BulkImportBlockSetsResponseV2_tamperedBundle, BulkImportBlockSetsResponseV2_unsignedBundle, CanCreateBlockVersionWithOutputResult, CanCreateBlockVersionWithOutputResultError, CanCreateBlockVersionWithOutputResultError_notAuthorizedToDeclassify, CanCreateBlockVersionWithOutputResultError_notAuthorizedToUseMarkings, CanCreateBlockVersionWithOutputResultError_resourcePermissionDenied, CanCreateBlockVersionWithOutputResultOk, CanCreateBlockVersionWithOutputResult_error, CanCreateBlockVersionWithOutputResult_ok, CanCreateBlockVersionWithOutputsRequest, CanCreateBlockVersionWithOutputsResponse, CancelFinalizeDraftGroupRequest, CancelFinalizeDraftGroupResponse, CancelInstallationJobAllowance, CancelInstallationJobAllowance_allowed, CancelInstallationJobAllowance_disallowed, CancelInstallationJobDisallowed, CancelInstallationJobPermissionDeniedRationale, CancelRecallAnnouncement, CancelRecallRequest, CancelRecallResponse, CannotChangeBackingDatasource, CannotUpgradeToDifferentBlockId, CarbonCreateBlockRequest, CarbonWorkspaceIdentifier, CarbonWorkspaceInputShape, CarbonWorkspaceOutputShape, CarbonWorkspaceRid, CatalogTransactionRid, Category, CategoryRid, CbacMarkingConstraint, CbacMarkingConstraintNotAllowed, Changelog, Changelog_markdown, CheckCanExportFromStoreResponse, CheckCanUploadToStoreResponse, CheckpointConfigCreateBlockRequest, CheckpointConfigEntityIdentifier, CheckpointConfigOutputShape, CheckpointConfigRid, ChildLevelAutomapping, CipherAlgorithm, CipherAlgorithm_aesGcmSiv, CipherAlgorithm_aesSiv, CipherAlgorithm_imageScrambling, CipherAlgorithm_sha256, CipherAlgorithm_sha512, CipherChannelAlgorithmMismatch, CipherChannelCreateBlockRequest, CipherChannelEntityIdentifier, CipherChannelInputShape, CipherChannelOutputShape, CipherChannelOutputSpecConfig, CipherChannelRid, CipherLicenseAlgorithmMismatch, CipherLicenseCreateBlockRequest, CipherLicenseEntityIdentifier, CipherLicenseInputIdentifier, CipherLicenseInputShape, CipherLicenseInputShapeV2, CipherLicenseMissingRequiredOperations, CipherLicenseMissingRequiredPermits, CipherLicenseOutputShape, CipherLicenseOutputSpecConfig, CipherLicensePermit, CipherLicensePermit_highTrustRequestPermit, CipherLicensePermit_rateLimitedRequestPermit, CipherLicensePermit_transformsRequestPermit, CipherLicenseRid, CipherLicenseType, CipherLicenseTypeMismatch, CipherLicenseType_adminLicense, CipherLicenseType_dataManagerLicense, CipherLicenseType_operationalUserLicense, CipherOperationType, CipherOperationType_decrypt, CipherOperationType_encrypt, CipherOperationType_hash, CipherTextPropertyType, CleanupUnusedShapeError, CleanupUnusedShapesSettings, CleanupUnusedShapesStatuses, CmafAudioCodec, CmafStreamingFormat, CmafVideoCodec, CodeBlockSetParentRid, CodeWorkspaceCreateBlockRequest, CodeWorkspaceIdentifier, CodeWorkspaceImageTypeMismatch, CodeWorkspaceInputShape, CodeWorkspaceLicenseIdentifier, CodeWorkspaceLicenseInputShape, CodeWorkspaceOutputShape, ColumnTypeMismatch, CompassContext, CompassContext_project, CompassCreateBlockRequest, CompassFolderRid, CompassFolderType, CompassFolderTypeConstraint, CompassFolderTypeConstraints, CompassInstallLocation, CompassProjectRid, CompassResourceInputIdentifier, CompassResourceInputShape, CompassResourceInputShapeTypeMismatch, CompassResourceOutputIdentifier, CompassResourceOutputShape, CompassResourceOutputShapeTypeMismatch, CompassResourceType, CompassResourceTypeConstraints, CompassResourceTypeConstraints_compassFolderTypeConstraints, CompassResourceType_compassFolderType, CompassSettings, ComputeModuleIncludeFunctionsType, ComputeModuleOutputSpecConfig, ComputeModuleType, ConcreteArrayType, ConcreteDataType, ConcreteDataType_array, ConcreteDataType_map, ConcreteDataType_primitive, ConcreteDataType_struct, ConcreteDecimalType, ConcreteMapType, ConcretePrimitiveDataType, ConcretePrimitiveDataType_binary, ConcretePrimitiveDataType_boolean, ConcretePrimitiveDataType_byte, ConcretePrimitiveDataType_date, ConcretePrimitiveDataType_decimal, ConcretePrimitiveDataType_double, ConcretePrimitiveDataType_float, ConcretePrimitiveDataType_integer, ConcretePrimitiveDataType_long, ConcretePrimitiveDataType_short, ConcretePrimitiveDataType_string, ConcretePrimitiveDataType_timestamp, ConcreteStructElement, ConcreteStructType, CondaExtension, CondaLocator, CondaLocatorV2, ConfigBlock, ConfigBlockKey, ConfigBlockValue, ConsistentBlockSetInstallationState, ConstraintFailure, ConstraintFailure_automationDisabled, ConstraintFailure_continuousInstallationHasBeenUpdatedRecently, ConstraintFailure_inProgressJobForBlockSetInstallation, ConstraintFailure_installationSpanningMultipleVersions, ConstraintFailure_isPartiallyDeletedInstallation, ConstraintFailure_lastUpgradeFailed, ConstraintFailure_missingInputs, ConstraintFailure_missingInputsV2, ConstraintFailure_noMaintenanceWindowsSet, ConstraintFailure_noNewerVersionsOnReleaseChannel, ConstraintFailure_outsideMaintenanceWindows, ConstraintFailure_qosThrottle, ConstraintFailure_unhandledValidationFailure, ConstraintFailure_unhandledValidationFailureV2, ConstraintFailure_unhandledValidationFailureV3, ConstraintFailures, ContainerImageType, ContainerRid, ContainerVersionId, ContourAnalysisEntityIdentifier, ContourAnalysisReference, ContourAnalysisRid, ContourAnalysisShape, ContourCreateBlockRequest, ContourIntegrationSource, ContourOutputSpecConfig, ContourRefEntityIdentifier, ContourRefReference, ContourRefRid, ContourRefShape, ContractExpressionIdentifier, ContractExpressionIdentifier_and, ContractExpressionIdentifier_contract, ContractExpressionIdentifier_or, CreateBlockSetFromStartingVersionRequest, CreateBlockSetVersionRequest, CreateBlockSetVersionResponse, CreateBlockVersionError, CreateBlockVersionErrorUnion, CreateBlockVersionErrorUnion_generic, CreateBlockVersionErrorUnion_genericV2, CreateBlockVersionErrorUnion_serializable, CreateBlockVersionRequest, CreateBlockVersionResponse, CreateDraftGroupRequest, CreateJobDraftRequest, CreateJobDraftResponse, CreateMarketplaceRequest, CreateNewBlockSetInstallation, CreatePlaceholdersRequest, CreatePlaceholdersResponse, CreateProductGroupRequest, CreateProductGroupResponse, CreateProjectRequest, CreateSnapshotRequest, CreateSnapshotResponse, CreationTimestamp, CredentialHasIncorrectSecretNames, CredentialRid, CronExpression, CronWithTimeZoneValue, CrossStackConfigSigningPublicKeyEntry, CrossStackConfigSigningPublicKeys, CryptographicKeyStrategy, CryptographicKeyStrategy_autoGenerateNewKey, CryptographicKeyStrategy_keepSameKey, CycleDependencyEdge, DataCommitBlockVersionFailedRequest, DataConstraints, DataHealthCheckCreateBlockRequest, DataHealthCheckGroupIdentifier, DataHealthCheckGroupRid, DataHealthCheckGroupShape, DataHealthCheckIdentifier, DataHealthCheckRid, DataHealthCheckShape, DataNullabilityV2, DataType, DataType_booleanType, DataType_cronWithTimeZoneType, DataType_integerType, DataType_stringType, DataValue, DataValue_booleanValue, DataValue_cronWithTimeZoneValue, DataValue_integerValue, DataValue_stringValue, DatasetLocator, DatasetLocatorIdentifier, DatasetOutputSpecConfig, DatasourceAlreadyBacksExistingLinkType, DatasourceAlreadyBacksExistingObjectType, DatasourceBackingRid, DatasourceBuildRequirements, DatasourceColumnIdentifier, DatasourceColumnIdentifier_nameBased, DatasourceColumnReference, DatasourceColumnShape, DatasourceColumnType, DatasourceColumnTypeClass, DatasourceColumnTypeClass_eddieDefined, DatasourceColumnTypeClass_valueType, DatasourceColumnType_concrete, DatasourceColumnType_generic, DatasourceLocator, DatasourceLocatorIdentifier, DatasourceLocatorIdentifier_dataset, DatasourceLocatorIdentifier_directSource, DatasourceLocatorIdentifier_restrictedView, DatasourceLocatorIdentifier_stream, DatasourceLocatorIdentifier_virtualTable, DatasourceLocatorTypeUnknown, DatasourceLocator_dataset, DatasourceLocator_directSource, DatasourceLocator_restrictedView, DatasourceLocator_stream, DatasourceLocator_virtualTable, DatasourceReference, DateListType, DateType, DayOfWeek, DayTime, DecimalListType, DecimalType, DeduplicateFunctionsApiStabilityConfiguration, DefaultBlockSpecificConfiguration, DefaultBlockSpecificConfiguration_v0, DefaultInstallationSettings, DefaultRequestedForShapeWithNoDefault, DefaultResolutionFailedError, DeleteBlockSetInstallationAllowance, DeleteBlockSetInstallationAllowance_allowed, DeleteBlockSetInstallationAllowance_disallowed, DeleteBlockSetInstallationDisallowed, DeleteBlockSetInstallationPermissionDeniedRationale, DeleteDraftGroupResponse, DeleteJobDraftResponse, DeleteKeyRequest, DeleteKeyResponse, DependencyProvenance, DeployedAppCreateBlockRequest, DeployedAppIdentifier, DeployedAppRid, DeployedAppShape, DeprecationStatus, DescriptionOverride, DescriptionOverrideRequest, DescriptionOverrideRequest_remove, DescriptionOverrideRequest_set, DiagramRid, DicomSchema, DiffGranularity, DirectDatasourceCreateBlockRequest, DirectSourceLocator, DirectSourceLocatorIdentifier, DiscoveryConfig, DiscoveryProvenance, DiscoverySettings, DiscoverySpec, DocFormat, DocumentDecodeFormat, DocumentDecodeFormat_doc, DocumentDecodeFormat_docx, DocumentDecodeFormat_pdf, DocumentDecodeFormat_pptx, DocumentDecodeFormat_rtf, DocumentDecodeFormat_txt, DocumentSchema, DocumentationManifestV1, DocxFormat, DoubleListType, DoubleType, DraftGroup, DraftGroupErrorStatus, DraftGroupFinalizedStatus, DraftGroupFinalizingStatus, DraftGroupGeneratingRecommendationsStatus, DraftGroupId, DraftGroupIdleStatus, DraftGroupProcessingStatus, DraftGroupRid, DraftGroupStatus, DraftGroupStatus_error, DraftGroupStatus_finalized, DraftGroupStatus_finalizing, DraftGroupStatus_generatingRecommendations, DraftGroupStatus_idle, DraftGroupStatus_processing, DuplicateBlockReference, DuplicateBlockSetVersionsInRequest, DuplicateColumns, DuplicateOutputs, DuplicateTabularDatasources, EddieAcknowledgeStateBreakOption, EddieCreateBlockRequest, EddieDefinedTypeClass, EddieDefinedTypeClassVersion, EddieEdgeParameterInputIdentifier, EddieEdgeParameterInputShape, EddieEdgeParameterShapeMergeKey, EddieEdgePipelineCreateBlockRequest, EddieEdgePipelineIdentifier, EddieEdgePipelineInputDatasetRid, EddieEdgePipelineOutputShape, EddieEdgePipelineRid, EddieEdgeStableParameterId, EddieGeotimeConfigurationInputShape, EddieGeotimeDestination, EddieGeotimeInputIdentifier, EddieGeotimeTargetId, EddieInputParameterType, EddieInputParameterType_primitive, EddieLiteralParameterType, EddieParameterShape, EddieParameterShapeV2, EddiePeeredGeotimeDestination, EddiePipelineIdentifier, EddiePipelineOutputSpecConfig, EddiePipelineRid, EddiePipelineShape, EddiePipelineType, EddiePrimitiveParameterType, EddiePrimitiveParameterType_literal, EddiePrimitiveParameterType_regex, EddieRemoteAndPeeredDestinationsConflictError, EddieReplayOptionShape, EddieReplayOptionType, EddieResetAndReplayFromOffsetOption, EddieResetOption, EddieTypeReference, EddieTypeReference_explicit, EddieVersionId, EdgeMagritteConfigKey, EdgeMagritteConfigValue, EdgeMagrittePortConfig, EdgeMagritteSourceConfig, EdgeMagritteTaskConfig, EdgeMagritteTaskType, EdgePipelineMagritteSourceInputIdentifier, EdgePipelineMagritteSourceInputShape, EdgePipelineMagritteSourceShapeMergeKey, EditBlockSetInstallationAllowance, EditBlockSetInstallationAllowance_allowed, EditBlockSetInstallationAllowance_disallowed, EditBlockSetInstallationDisallowed, EditBlockSetInstallationSettingsAllowance, EditBlockSetInstallationSettingsAllowance_allowed, EditBlockSetInstallationSettingsAllowance_disallowed, EditBlockSetInstallationSettingsDisallowed, EditBlockSetInstallationsPermissionDeniedRationale, EditProductGroupRequest, EditProductGroupResponse, EditsSupportIncompatible, EditsViewCreateBlockRequest, EmailDecodeFormat, EmailDecodeFormat_eml, EmailSchema, EmlFormat, Empty, EnrollmentCreationStateMachineId, EnrollmentRid, Envelope, EquivalentInputActionTypeParameterShapeReferences, EquivalentInputReferences, EquivalentInputReferences_equivalentInputActionTypeParameterShapeReferences, EquivalentInputReferences_equivalentInputShapeReferences, EquivalentInputShapeReferences, ErrorArg, ErrorGranularOutputSpecResult, ErrorInstanceId, ErrorLevel, ErrorProductGroupValidationStatus, ErrorSeverity, EvaluationSuiteCreateBlockRequest, EvaluationSuiteIdentifier, EvaluationSuiteRid, EvaluationSuiteShape, ExistingAssociatedBlockSetInstallation, ExistingFolder, ExistingFolderV2, ExpectedDefaultNotEqualToActualDefault, ExpectedDefaultNotEqualToActualDefaultV2, ExpectedLinkedInterfaceButWasObject, ExpectedLinkedObjectButWasInterface, ExpirationStrategy, ExpirationStrategy_fixedDate, ExpirationStrategy_relativeDate, ExplicitInputShapeRequest, ExplicitInputShapeResult, ExplicitProvenance, ExportBlockRequest, ExportBlockRequestFileType, ExportBlockRequestFileTypeZip, ExportBlockRequestFileType_zip, ExportBlockSetRequest, ExportCompatibility, ExportMultipleBlockSetsRequest, ExportPermissionDeniedReason, ExternalRecommendationDisplayMetadata, ExternalRecommendationInstallationVisibility, ExternalRecommendationInstallationVisibility_disabled, ExternalRecommendationInstallationVisibility_enabled, ExternalRecommendationInstallationVisibility_featured, ExternalRecommendationMavenDependencyRequirement, ExternalRecommendationMavenDependencyRequirement_ignored, ExternalRecommendationMavenDependencyRequirement_optional, ExternalRecommendationMavenDependencyRequirement_required, ExternalRecommendationSource, ExternalRecommendationSource_otherStoreLocal, ExternalRecommendationSource_otherStoreRemote, ExternalRecommendationSource_owned, ExternalRecommendationSource_ownedPending, ExternalRecommendationSource_upstreamInstallationLocal, ExternalRecommendationSource_upstreamInstallationRemote, ExternalRecommendationToSelf, ExternalRecommendationUsedForInputShapeWithMandatoryPresets, ExternalRecommendationV2, ExternalServiceError, ExternallyRecommendedOutput, ExternallyRecommendedOutputV2, FailedConstraintsStatus, FailedInstallBlocksResponse, FailedToDeleteResourcesError, FailedToSubmitJobResult, FileSizeInBytes, Filename, FilesDatasourceInputIdentifier, FilesDatasourceInputShape, FilesDatasourceInputType, FilesDatasourceInputType_dataset, FilesDatasourceInputType_mediaSet, FilesDatasourceLocator, FilesDatasourceLocator_dataset, FilesDatasourceLocator_mediaSet, FilesDatasourceOutputIdentifier, FilesDatasourceOutputShape, FilesDatasourceOutputType, FilesDatasourceOutputType_dataset, FilesDatasourceOutputType_mediaSet, FilesDatasourceReference, FilesDatasourceTypeNotSupported, FilesLocator, FinalizeBlockSetVersionRequest, FinalizeBlockSetVersionResponse, FinalizeDraftGroupRequest, FinalizeDraftGroupResponse, FinalizedBlockSetVersionStatus, FinalizedStatusV3, FinalizingStatusV3, FinishedInstallPendingStatus, FlacFormat, FlinkProfileIdentifier, FlinkProfileName, FlinkProfileShape, FolderInputExternallyRecommended, FolderInputNotSetToInstallationFolder, FolderInputPreventsInstallingInNewProject, FolderInputRequiresInstallingIntoExistingFolder, FoundryPeerProducerProfileCreateBlockRequest, FoundryProductsDownloaderStore, FreeFormDocumentation, FreeFormDocumentationSection, FreeFormDocumentationSections, FreeFormDocumentation_markdown, FromDefaultInput, FromSourceResolvedPresetValue, FunctionApiName, FunctionApiName_global, FunctionApiName_ontologyBound, FunctionConfigurationIdentifier, FunctionConfigurationRid, FunctionConfigurationShape, FunctionConfigurationsCreateBlockRequest, FunctionContractApiName, FunctionContractApiNameIdentifier, FunctionContractIdentifier, FunctionContractIdentifier_apiName, FunctionContractIdentifier_rid, FunctionContractNotImplemented, FunctionContractReference, FunctionContractRid, FunctionContractRidIdentifier, FunctionContractShape, FunctionContractVersion, FunctionContractVersionReference, FunctionContractsIdentifier, FunctionContractsIdentifier_all, FunctionContractsIdentifier_expression, FunctionContractsIdentifier_none, FunctionContractsIdentifier_subset, FunctionCustomTypeDataTypeActionTypeReferencesNotSupported, FunctionCustomTypeDataTypeCustomTypeNotFound, FunctionCustomTypeDataTypeInterfaceTypeUnresolvable, FunctionCustomTypeDataTypeMarkingSubTypeUnknown, FunctionCustomTypeDataTypeObjectTypeUnresolvable, FunctionCustomTypeDataTypeUnknown, FunctionDataTypeValueTypeUnresolvable, FunctionDataTypeValueTypeUnresolvableV2, FunctionDoesNotSatisfyContractExpression, FunctionExtraInputDataTypeUnknown, FunctionInputDataTypeActionTypeReferencesUnsupported, FunctionInputDataTypeActionTypeReferencesUnsupportedV2, FunctionInputDataTypeCustomTypeNotFound, FunctionInputDataTypeCustomTypeNotFoundV2, FunctionInputDataTypeInterfaceTypeRidUnresolvable, FunctionInputDataTypeMarkingSubTypeUnknown, FunctionInputDataTypeMarkingSubTypeUnknownV2, FunctionInputDataTypeMismatch, FunctionInputDataTypeMismatchV2, FunctionInputDataTypeObjectTypeIdUnresolvable, FunctionInputDataTypeObjectTypeIdUnresolvableV2, FunctionInputDataTypeUnknown, FunctionInputDataTypeUnknownV2, FunctionInputIdentifier, FunctionInputIdentifier_languageModelRid, FunctionInputIdentifier_rid, FunctionInputIdentifier_ridAndVersion, FunctionInputIdentifier_staticInput, FunctionInputName, FunctionInputNamesDiffer, FunctionInputNotFound, FunctionInputNotFoundV2, FunctionInputNotOptional, FunctionInputNotOptionalV2, FunctionInputShape, FunctionInputType, FunctionInputTypeDisplayMetadata, FunctionLanguageModelRidIdentifier, FunctionNotFound, FunctionOutputDataTypeActionTypeReferencesUnsupported, FunctionOutputDataTypeCustomTypeNotFound, FunctionOutputDataTypeInterfaceTypeRidUnresolvable, FunctionOutputDataTypeMarkingSubTypeUnknown, FunctionOutputDataTypeMismatch, FunctionOutputDataTypeObjectTypeIdUnresolvable, FunctionOutputDataTypeUnknown, FunctionOutputIdentifier, FunctionOutputIdentifier_rid, FunctionOutputIdentifier_ridAndVersion, FunctionOutputShape, FunctionOutputType, FunctionOutputTypeDisplayMetadata, FunctionOutputTypeDisplayMetadata_singleOutputType, FunctionOutputTypeMismatch, FunctionOutputTypeUnknown, FunctionOutputType_singleOutputType, FunctionOutputType_voidOutputType, FunctionPackageCandidateIdentifier, FunctionPackageCandidateLocator, FunctionPackageConfigurationCreateBlockRequest, FunctionPackageConfigurationIdentifier, FunctionPackageConfigurationIdentifier_candidateFunction, FunctionPackageConfigurationRid, FunctionPackageConfigurationShape, FunctionPackageLocator, FunctionPackageLocator_candidateFunction, FunctionPackageShapeReference, FunctionPackageShapeReference_repository, FunctionReference, FunctionRid, FunctionRidAndVersionIdentifier, FunctionRidAndVersionRangeIdentifier, FunctionRidIdentifier, FunctionRidOutputIdentifier, FunctionShapeConversionError, FunctionShapeConversionFailedReason, FunctionShapeConversionFailedReason_customTypeDataTypeConversion, FunctionShapeConversionFailedReason_inputDataTypeConversion, FunctionShapeConversionFailedReason_outputDataTypeConversion, FunctionShapeCustomTypeDataTypeConversionFailed, FunctionShapeDataTypeConversionError, FunctionShapeDataTypeConversionError_unknownBucketKeyType, FunctionShapeDataTypeConversionError_unknownBucketValueType, FunctionShapeDataTypeConversionError_unknownDataType, FunctionShapeDataTypeConversionError_unknownGeoShapeSubType, FunctionShapeDataTypeConversionError_unknownLogicalTypeReferenceType, FunctionShapeDataTypeConversionError_unknownMarkingSubType, FunctionShapeDataTypeConversionError_unknownRangeType, FunctionShapeDataTypeConversionError_unknownTimeSeriesValueType, FunctionShapeDataTypeConversionError_unknownVectorElementType, FunctionShapeDataTypeConversionError_unresolvableCrossShapeReference, FunctionShapeDataTypeConversionError_unsupportedDataType, FunctionShapeDisplayMetadata, FunctionShapeInputDataTypeConversionFailed, FunctionShapeOutputDataTypeConversionFailed, FunctionShapeSignatureCompatibilityError, FunctionShapeSignatureIncompatibleInputTypeChange, FunctionShapeSignatureIncompatibleOutputTypeChange, FunctionShapeSignatureIncompatibleReason, FunctionShapeSignatureIncompatibleReason_incompatibleInputTypeChange, FunctionShapeSignatureIncompatibleReason_incompatibleOutputTypeChange, FunctionShapeSignatureIncompatibleReason_missingInput, FunctionShapeSignatureIncompatibleReason_unknownRequiredInput, FunctionShapeSignatureMissingInput, FunctionShapeSignatureUnknownRequiredInput, FunctionShapeStableId, FunctionShapeStableId_staticInput, FunctionShapeUnknownBucketKeyType, FunctionShapeUnknownBucketValueType, FunctionShapeUnknownDataType, FunctionShapeUnknownGeoShapeSubType, FunctionShapeUnknownLogicalTypeReference, FunctionShapeUnknownMarkingSubType, FunctionShapeUnknownRangeType, FunctionShapeUnknownTimeSeriesValueType, FunctionShapeUnknownVectorElementType, FunctionShapeUnresolvableCrossShapeReference, FunctionShapeUnsupportedDataType, FunctionStaticInputIdentifier, FunctionStaticInputStableId, FunctionVersion, FunctionVersionRange, FunctionVersionsConfiguration, FunctionVersionsConfigurationInputIdentifier, FunctionVersionsConfigurationInputShape, FunctionVersionsConfiguration_incrementMinor, FunctionVersionsConfiguration_preserve, FunctionsApiStabilityConfiguration, FunctionsApiStabilityConfigurationInputIdentifier, FunctionsApiStabilityConfigurationInputShape, FunctionsApiStabilityConfiguration_deduplicate, FunctionsApiStabilityConfiguration_stable, FunctionsCreateBlockRequest, FusionDocumentIdentifier, FusionDocumentShape, GenerateCompassLocationInputShapesFailure, GenerateCompassLocationInputShapesRequest, GenerateCompassLocationInputShapesResponse, GenerateCompassLocationInputShapesResponseV2, GenerateCompassLocationInputShapesResponseV2_failure, GenerateCompassLocationInputShapesResponseV2_success, GenerateCompassShapesError, GenerateInputGroupRequest, GenerateInputShapeRequest, GenerateOutputShapeRequest, GenerateShapesError, GenerateShapesErrorV2, GenerateShapesError_actionTypeNotFound, GenerateShapesError_actionTypeParameterNotFound, GenerateShapesError_functionNotFound, GenerateShapesError_inputGroupWithUnknownReference, GenerateShapesError_interfaceActionTypeConstraintNotFound, GenerateShapesError_interfaceLinkTypeNotFound, GenerateShapesError_interfacePropertyTypeNotFound, GenerateShapesError_linkTypeNotFound, GenerateShapesError_objectInstanceNotFound, GenerateShapesError_objectTypeNotFound, GenerateShapesError_ontologyDatasourceNotFound, GenerateShapesError_ontologyInterfaceTypeNotFound, GenerateShapesError_propertyTypeNotFound, GenerateShapesError_serializable, GenerateShapesError_sharedPropertyTypeNotFound, GenerateShapesError_unknownError, GenerateShapesRequest, GenerateShapesResponse, GenerateShapesResponseFailure, GenerateShapesResponseSuccess, GenerateShapesResponse_failure, GenerateShapesResponse_success, GenerateShapesWithoutBlockRequest, GenericBlockInstallServiceValidationError, GenericCreateBlockVersionError, GenericCreateBlockVersionErrorV2, GenericDataType, GenericDataType_any, GenericDataType_anyDecimal, GenericDataType_oneOf, GenericDiffBlockInstallServiceValidationError, GeohashListType, GeohashType, GeoshapeListType, GeoshapeType, GeotimeSeriesIntegrationRid, GeotimeSeriesIntegrationShape, GeotimeSeriesReferenceListType, GeotimeSeriesReferenceType, GetBlockSetResponse, GetBlockSetShapesResponse, GetBlockSetVersionChangelogResponse, GetBlockSetVersionDocumentationResponse, GetBlockSetVersionSpecsResponse, GetBlockSetVersionStatusResponseV3, GetBlockVersionChangelogResponse, GetBlockVersionResponse, GetDownstreamRecommendationsResponse, GetDraftGroupStatusResponse, GetGranularBlockSetStatisticsResponse, GetGranularBlockSetStatisticsV3Response, GetInstallAutomationSettingsResponse, GetInstallAutomationStatusResponse, GetInstallableBlockSetVersionResponse, GetInstallableBlockSetVersionResponseV2, GetInstallableBlockVersionResponse, GetJobDraftMetadataResponse, GetJobDraftStatusResponse, GetKeysResponse, GetLatestBlockVersionResponse, GetManagedStoresResponse, GetManagedStoresSettingsForOrgResponse, GetMarketplaceMavenGroupResponse, GetMarketplaceRidForMavenGroupRequest, GetMarketplaceRidForMavenGroupResponse, GetOwnedBlockVersionResponse, GetPendingBlockSetShapesResponse, GetPendingBlockSetVersionBlocksResponse, GetPendingBlockSetVersionMetadataResponse, GetPendingBlockVersionResponse, GetPendingRecommendationsResponse, GetProductGroupResponse, GetProductGroupSnapshotResponse, GetProductGroupVersionResponse, GetProductVersionMetadataResponse, GetRecallsForBlockSetResponse, GetRecommendationsResponse, GetRecommendationsResponsePending, GetRecommendationsResponseSuccess, GetRecommendationsResponseV2, GetRecommendationsResponseV2_pending, GetRecommendationsResponseV2_success, GetResolvedJobDraftResponse, GetSigningKeyResponse, GetUnresolvedJobDraftResponse, GetUserUploadPermissionQuotaResponse, GlobalFunctionApiName, GranularBlockInputShapeSizeLimitCount, GranularBlockInputShapeSizeLimitCountV3, GranularBlockSetInputShapeSizeLimitCountV3, GranularBlockSetLimits, GranularBlockSetOutputShapeSizeLimitCount, GranularBlockSetOutputShapeSizeLimitCountV3, GranularBlockSetStatistics, GranularBlockSetStatisticsV3, GranularBlockSizeLimitCount, GranularErrorStatus, GranularErrorStatus_buildCancelled, GranularErrorStatus_buildErrored, GranularErrorStatus_buildTimedOut, GranularErrorStatus_inProgressCancelled, GranularErrorStatus_inProgressError, GranularInstallPendingStatus, GranularInstallPendingStatus_building, GranularInstallPendingStatus_finished, GranularInstallPendingStatus_notStarted, GranularInstallPendingStatus_pendingBuild, GranularInstallPendingStatus_preallocating, GranularInstallPendingStatus_reconciling, GranularOutputSpecResult, GranularOutputSpecResult_dataUploading, GranularOutputSpecResult_error, GranularOutputSpecResult_ignored, GranularOutputSpecResult_materializing, GranularOutputSpecResult_success, GranularOutputSpecResult_unsupported, GroupAlreadyUsedFailure, GroupFilter, GroupId, GroupMalformedFailure, GroupReference, HighTrustRequestPermit, IdleBlockSetVersionStatus, IdleStatus, IdleStatusV3, IgnoreConfig, ImageryDecodeFormat, ImageryDecodeFormat_bmp, ImageryDecodeFormat_jp2k, ImageryDecodeFormat_jpg, ImageryDecodeFormat_nitf, ImageryDecodeFormat_png, ImageryDecodeFormat_tiff, ImageryDecodeFormat_webp, ImagerySchema, ImportBlockSetResponse, ImportTimestamp, InProgressCancelled, InProgressError, IncludeFunctionsConfig, IncludeHealthCheckConfig, IncludeModelContent, IncludeObjectViewsConfig, IncludeOntologyEntitiesConfig, IncludeSchedulesConfig, IncompatibleContractSemverError, IncompatibleExternalRecommendationVersionRange, IncompatibleLinkedProduct, IncompatibleSemverError, IncrementMinorFunctionVersionsConfiguration, IndexFailure, IndexTimeout, IndexableEntityIds, IndexableEntityRid, IndistinguishableInputShapesError, InferredFolderStructureSettings, InferredFolderStructureSettings_disabled, InferredFolderStructureSettings_enabled, InitializingStatusV3, InlineActionTypeMissing, InputBlockSetMappingInfo, InputBlockSetShapeAboutMetadata, InputBlockSetShapeId, InputBlockSetShapeMetadata, InputDependencyCycle, InputDownstreamOfOutputsInJobSpecGraph, InputEditsSupport, InputEntityIdentifier, InputEntityIdentifier_action, InputEntityIdentifier_actionParameter, InputEntityIdentifier_aipAgent, InputEntityIdentifier_allowOntologySchemaMigrations, InputEntityIdentifier_artifactsRepository, InputEntityIdentifier_authoringLibrary, InputEntityIdentifier_authoringRepository, InputEntityIdentifier_automation, InputEntityIdentifier_autopilotWorkbench, InputEntityIdentifier_blobster, InputEntityIdentifier_carbonWorkspace, InputEntityIdentifier_cipherChannel, InputEntityIdentifier_cipherLicense, InputEntityIdentifier_cipherLicenseV2, InputEntityIdentifier_codeWorkspace, InputEntityIdentifier_codeWorkspaceLicense, InputEntityIdentifier_compassResource, InputEntityIdentifier_contourAnalysis, InputEntityIdentifier_contourRef, InputEntityIdentifier_dataHealthCheck, InputEntityIdentifier_dataHealthCheckGroup, InputEntityIdentifier_datasourceColumn, InputEntityIdentifier_deployedApp, InputEntityIdentifier_eddieEdgeParameter, InputEntityIdentifier_eddieGeotimeConfiguration, InputEntityIdentifier_eddieParameter, InputEntityIdentifier_eddieParameterV2, InputEntityIdentifier_eddiePipeline, InputEntityIdentifier_eddieReplayOption, InputEntityIdentifier_edgePipelineMagritteSource, InputEntityIdentifier_evaluationSuite, InputEntityIdentifier_filesDatasource, InputEntityIdentifier_flinkProfile, InputEntityIdentifier_function, InputEntityIdentifier_functionContract, InputEntityIdentifier_functionVersionsConfiguration, InputEntityIdentifier_functionsApiStabilityConfiguration, InputEntityIdentifier_fusionDocument, InputEntityIdentifier_geotimeSeriesIntegration, InputEntityIdentifier_installPrefix, InputEntityIdentifier_interfaceActionTypeConstraint, InputEntityIdentifier_interfaceLinkType, InputEntityIdentifier_interfaceParameterConstraint, InputEntityIdentifier_interfacePropertyType, InputEntityIdentifier_interfaceType, InputEntityIdentifier_languageModel, InputEntityIdentifier_link, InputEntityIdentifier_logic, InputEntityIdentifier_logicFunction, InputEntityIdentifier_machinery, InputEntityIdentifier_magritteConnection, InputEntityIdentifier_magritteExport, InputEntityIdentifier_magritteSource, InputEntityIdentifier_magritteSourceConfigOverrides, InputEntityIdentifier_magritteStreamingExtractConfigOverrides, InputEntityIdentifier_markings, InputEntityIdentifier_model, InputEntityIdentifier_modelStudio, InputEntityIdentifier_monitorView, InputEntityIdentifier_monocleGraph, InputEntityIdentifier_multipassGroup, InputEntityIdentifier_multipassUserAttribute, InputEntityIdentifier_namedCredential, InputEntityIdentifier_networkEgressPolicy, InputEntityIdentifier_notepadDocument, InputEntityIdentifier_notepadTemplate, InputEntityIdentifier_notepadTemplateParameter, InputEntityIdentifier_objectInstance, InputEntityIdentifier_objectSet, InputEntityIdentifier_objectType, InputEntityIdentifier_objectView, InputEntityIdentifier_objectViewTab, InputEntityIdentifier_ontologyDatasource, InputEntityIdentifier_ontologySdk, InputEntityIdentifier_parameter, InputEntityIdentifier_peerProducerProfile, InputEntityIdentifier_peerProfile, InputEntityIdentifier_peerProfileRemoteStrategy, InputEntityIdentifier_property, InputEntityIdentifier_quiverDashboard, InputEntityIdentifier_schedule, InputEntityIdentifier_sharedPropertyType, InputEntityIdentifier_slateApplication, InputEntityIdentifier_solutionDesign, InputEntityIdentifier_sparkProfile, InputEntityIdentifier_sqlWorksheet, InputEntityIdentifier_storedProcedure, InputEntityIdentifier_tabularDatasource, InputEntityIdentifier_taurusWorkflow, InputEntityIdentifier_thirdPartyApplication, InputEntityIdentifier_timeSeriesSync, InputEntityIdentifier_valueType, InputEntityIdentifier_vectorWorkbook, InputEntityIdentifier_versionedObjectSet, InputEntityIdentifier_vertexTemplate, InputEntityIdentifier_vortexTemplate, InputEntityIdentifier_walkthrough, InputEntityIdentifier_webhook, InputEntityIdentifier_widget, InputEntityIdentifier_widgetSet, InputEntityIdentifier_workbenchTemplate, InputEntityIdentifier_workflowBuilderGraph, InputEntityIdentifier_workflowGraph, InputEntityIdentifier_workshop, InputEntityIdentifier_workshopSaveLocation, InputGroup, InputGroupBlockSetMappingInfo, InputGroupDisplayMetadata, InputGroupDoesNotExistInBlockError, InputGroupId, InputGroupResult, InputGroupValidationErrors, InputGroupValidationErrors_inputGroupDoesNotExistInBlock, InputGroupWithUnknownReference, InputLinkTypeIdentifier, InputObjectBackendVersion, InputObjectTypeIdentifier, InputPreset, InputPresetResolutionResult, InputRecommendationV2, InputShape, InputShapeMetadata, InputShapeNotSpecified, InputShapeResolver, InputShapeResolver_apiNameResolver, InputShapeResolver_linkTypeIdResolver, InputShapeResolver_markingsResolver, InputShapeResolver_multipassGroupResolver, InputShapeResolver_resolvedShapeResolver, InputShapeResolver_valueTypePresetResolver, InputShapeResult, InputShapeType, InputShapeVersionAndBlockSetOutputs, InputShape_action, InputShape_actionParameter, InputShape_aipAgent, InputShape_allowOntologySchemaMigrations, InputShape_artifactsRepository, InputShape_authoringLibrary, InputShape_authoringRepository, InputShape_automation, InputShape_autopilotWorkbench, InputShape_blobsterResource, InputShape_carbonWorkspace, InputShape_cipherChannel, InputShape_cipherLicense, InputShape_cipherLicenseV2, InputShape_codeWorkspace, InputShape_codeWorkspaceLicense, InputShape_compassResource, InputShape_contourAnalysis, InputShape_contourRef, InputShape_dataHealthCheck, InputShape_dataHealthCheckGroup, InputShape_datasourceColumn, InputShape_deployedApp, InputShape_eddieEdgeParameter, InputShape_eddieGeotimeConfiguration, InputShape_eddieParameter, InputShape_eddieParameterV2, InputShape_eddiePipeline, InputShape_eddieReplayOption, InputShape_edgePipelineMagritteSource, InputShape_evaluationSuite, InputShape_filesDatasource, InputShape_flinkProfile, InputShape_function, InputShape_functionContract, InputShape_functionVersionsConfiguration, InputShape_functionsApiStabilityConfiguration, InputShape_fusionDocument, InputShape_geotimeSeriesIntegration, InputShape_installPrefix, InputShape_interfaceActionTypeConstraint, InputShape_interfaceLinkType, InputShape_interfaceParameterConstraint, InputShape_interfacePropertyType, InputShape_interfaceType, InputShape_languageModel, InputShape_linkType, InputShape_logic, InputShape_logicFunction, InputShape_machinery, InputShape_magritteConnection, InputShape_magritteExport, InputShape_magritteSource, InputShape_magritteSourceConfigOverrides, InputShape_magritteStreamingExtractConfigOverrides, InputShape_markings, InputShape_model, InputShape_modelStudio, InputShape_monitorView, InputShape_monocleGraph, InputShape_multipassGroup, InputShape_multipassUserAttribute, InputShape_namedCredential, InputShape_networkEgressPolicy, InputShape_notepadDocument, InputShape_notepadTemplate, InputShape_notepadTemplateParameter, InputShape_objectInstance, InputShape_objectSet, InputShape_objectType, InputShape_objectView, InputShape_objectViewTab, InputShape_ontologyDatasource, InputShape_ontologyDatasourceRetention, InputShape_ontologySdk, InputShape_overrideOntologyEntityApiNames, InputShape_parameter, InputShape_peerProducerProfile, InputShape_peerProfile, InputShape_peerProfileRemoteStrategy, InputShape_property, InputShape_quiverDashboard, InputShape_schedule, InputShape_sharedPropertyType, InputShape_slateApplication, InputShape_solutionDesign, InputShape_sparkProfile, InputShape_sqlWorksheet, InputShape_storedProcedure, InputShape_tabularDatasource, InputShape_taurusWorkflow, InputShape_thirdPartyApplication, InputShape_timeSeriesSync, InputShape_valueType, InputShape_vectorWorkbook, InputShape_versionedObjectSet, InputShape_vertexTemplate, InputShape_vortexTemplate, InputShape_walkthrough, InputShape_webhook, InputShape_widget, InputShape_widgetSet, InputShape_workbenchTemplate, InputShape_workflowBuilderGraph, InputShape_workflowGraph, InputShape_workshopApplication, InputShape_workshopApplicationSaveLocation, InstallAutomationSettings, InstallBlockFinishedMetadata, InstallBlockSetPermissionDeniedRationale, InstallBlockSetShapeValidationError, InstallBlockSetsRequest, InstallBlockSetsResponse, InstallBlockSetsResult, InstallBlockSetsResult_failedToSubmitJob, InstallBlockSetsResult_invalidRequest, InstallBlockSetsResult_jobSubmitted, InstallBlocksJobId, InstallBlocksJobRid, InstallBlocksRequest, InstallBlocksRequestV2, InstallBlocksResponseV2, InstallBlocksResponseV2_failed, InstallBlocksResponseV2_inProgress, InstallBlocksResponseV2_invalidRequest, InstallBlocksStatus, InstallBlocksStatusBuilding, InstallBlocksStatusError, InstallBlocksStatusPending, InstallBlocksStatusSuccess, InstallBlocksStatus_building, InstallBlocksStatus_error, InstallBlocksStatus_pending, InstallBlocksStatus_success, InstallExistingBlockInstruction, InstallFromMarketplacePermissionDeniedRationale, InstallInOntologyPermissionDeniedRationale, InstallLocationBlockShapeId, InstallNewBlockInstruction, InstallNewBlockInstructionId, InstallPendingMetadata, InstallPrefixConfigurationEnum, InstallPrefixShape, InstallShapeValidationError, InstallShapeValidationErrorV2, InstallShapeValidationErrorV3, InstallShapeValidationError_actionParameterShapeErrors, InstallShapeValidationError_actionTypeParameterNotFound, InstallShapeValidationError_actionTypeParameterShapeErrorV2, InstallShapeValidationError_actionTypeWithNestedParameters, InstallShapeValidationError_apiNameMismatch, InstallShapeValidationError_attachNotSupported, InstallShapeValidationError_attachedOutputCreatedInAnotherInstallation, InstallShapeValidationError_attachedOutputShapeNotSpecified, InstallShapeValidationError_authoringLibraryNotFound, InstallShapeValidationError_blobsterResourceShapeError, InstallShapeValidationError_cipherChannelAlgorithmMismatch, InstallShapeValidationError_cipherLicenseAlgorithmMismatch, InstallShapeValidationError_cipherLicenseMissingRequiredOperations, InstallShapeValidationError_cipherLicenseMissingRequiredPermits, InstallShapeValidationError_cipherLicenseTypeMismatch, InstallShapeValidationError_classificationConstraintsNotSatisfied, InstallShapeValidationError_codeWorkspaceImageTypeMismatch, InstallShapeValidationError_columnNotFound, InstallShapeValidationError_columnShapeError, InstallShapeValidationError_compassResourceInTrash, InstallShapeValidationError_compassResourceShapeError, InstallShapeValidationError_connectionNotFound, InstallShapeValidationError_connectionReferenceMismatch, InstallShapeValidationError_connectionReferenceNotResolved, InstallShapeValidationError_connectionTypeMismatch, InstallShapeValidationError_connectionTypeUnsupported, InstallShapeValidationError_credentialHasIncorrectSecretNames, InstallShapeValidationError_defaultRequestedForShapeWithNoDefault, InstallShapeValidationError_defaultResolutionFailedError, InstallShapeValidationError_eddieRemoteAndPeeredDestinationsConflictError, InstallShapeValidationError_expectedDefaultNotEqualToActualDefault, InstallShapeValidationError_expectedDefaultNotEqualToActualDefaultV2, InstallShapeValidationError_externalRecommendationsUsedForInputShapeWithMandatoryPresets, InstallShapeValidationError_filesDatasourceTypeNotSupported, InstallShapeValidationError_flinkProfileNotFound, InstallShapeValidationError_folderInputExternallyRecommended, InstallShapeValidationError_folderInputNotSetToInstallationFolder, InstallShapeValidationError_folderInputRequiresInstallingIntoExistingFolder, InstallShapeValidationError_functionNotFound, InstallShapeValidationError_functionShapeError, InstallShapeValidationError_functionShapeErrorV2, InstallShapeValidationError_genericDiffServiceValidationError, InstallShapeValidationError_genericServiceValidationError, InstallShapeValidationError_incompatibleSemverBlocking, InstallShapeValidationError_incompatibleSemverNonBlocking, InstallShapeValidationError_inputActionTypeNotFound, InstallShapeValidationError_inputDownstreamOfOutputsInJobSpecGraph, InstallShapeValidationError_inputShapeNotSpecified, InstallShapeValidationError_inputShapeTypeMismatch, InstallShapeValidationError_installPrefixShapeError, InstallShapeValidationError_interfaceActionTypeConstraintMissingParameterConstraints, InstallShapeValidationError_interfaceActionTypeConstraintNotFound, InstallShapeValidationError_interfaceActionTypeConstraintShapeError, InstallShapeValidationError_interfaceLinkTypeNotFound, InstallShapeValidationError_interfaceLinkTypeShapeError, InstallShapeValidationError_interfaceParameterConstraintNotFound, InstallShapeValidationError_interfaceParameterConstraintShapeError, InstallShapeValidationError_interfacePropertyTypeNotFound, InstallShapeValidationError_interfacePropertyTypeShapeError, InstallShapeValidationError_interfaceTypeMissingActionTypeConstraints, InstallShapeValidationError_interfaceTypeMissingExtendedInterfaces, InstallShapeValidationError_interfaceTypeMissingLinks, InstallShapeValidationError_interfaceTypeMissingProperties, InstallShapeValidationError_interfaceTypeNotFound, InstallShapeValidationError_invalidCronExpression, InstallShapeValidationError_invalidZoneId, InstallShapeValidationError_linkTypeNotFound, InstallShapeValidationError_linkTypeShapeError, InstallShapeValidationError_magritteSourceApiNameMismatch, InstallShapeValidationError_magritteSourceMissingRequiredSecrets, InstallShapeValidationError_magritteSourceMissingRequiredUsageRestrictions, InstallShapeValidationError_magritteSourceNotFound, InstallShapeValidationError_magritteSourceTypeMismatch, InstallShapeValidationError_mandatoryPresetNotUsed, InstallShapeValidationError_markingNotFound, InstallShapeValidationError_markingSizeConstraintsNotSatisfied, InstallShapeValidationError_markingTypeNotValid, InstallShapeValidationError_markingTypeNotValidV2, InstallShapeValidationError_markingTypeNotValidV3, InstallShapeValidationError_mediaSetIncompatiblePathPolicy, InstallShapeValidationError_mediaSetIncompatibleSchema, InstallShapeValidationError_mediaSetIncompatibleSchemaV2, InstallShapeValidationError_mediaSetIncompatibleTransactionPolicy, InstallShapeValidationError_mediaSetNotSupported, InstallShapeValidationError_modelResourceShapeError, InstallShapeValidationError_notepadTemplateNotFound, InstallShapeValidationError_notepadTemplateParameterNotFound, InstallShapeValidationError_notepadTemplateParameterShapeError, InstallShapeValidationError_objectTypeForObjectViewNotFound, InstallShapeValidationError_objectTypeNotFound, InstallShapeValidationError_objectTypeShapeError, InstallShapeValidationError_omittedShapeForShapeWithPresets, InstallShapeValidationError_ontologyDatasourceMissingFromEntity, InstallShapeValidationError_ontologyEntityNotInTargetOntology, InstallShapeValidationError_ontologyInstallLocationNotDefined, InstallShapeValidationError_outputOwnedByAnotherInstallation, InstallShapeValidationError_outputShapeTypeMismatch, InstallShapeValidationError_parameterTypeMismatch, InstallShapeValidationError_peerProfileRemoteStrategyMismatch, InstallShapeValidationError_presetResolutionFailedError, InstallShapeValidationError_propertyTypeNotFound, InstallShapeValidationError_propertyTypeShapeError, InstallShapeValidationError_resolvedOutputShapeAttachedMultipleTimes, InstallShapeValidationError_resourceIsNotChildOfTargetCompassFolder, InstallShapeValidationError_resourceNotFound, InstallShapeValidationError_scheduleShapeInvalid, InstallShapeValidationError_serializable, InstallShapeValidationError_sharedPropertyTypeNotFound, InstallShapeValidationError_sharedPropertyTypeShapeError, InstallShapeValidationError_sparkProfile, InstallShapeValidationError_sparkProfileFamilyMismatch, InstallShapeValidationError_stringParameterMaxLengthExceeded, InstallShapeValidationError_tabularDatasourceShapeError, InstallShapeValidationError_typedBlockInstallServiceValidationError, InstallShapeValidationError_valueTypeShapeValidationError, InstallShapeValidationError_versionMismatch, InstallShapeValidationError_versionedObjectSetNotLatest, InstallShapeValidationErrors, InstallValidationError, InstallValidationErrorDetail, InstallValidationErrorDetail_associatedWithMultipleBlockSetInstallations, InstallValidationErrorDetail_attachResourceValidationErrors, InstallValidationErrorDetail_blockVersionIdDoesNotExist, InstallValidationErrorDetail_cannotUpgradeToDifferentBlockId, InstallValidationErrorDetail_externalServiceError, InstallValidationErrorDetail_inputGroupValidationErrors, InstallValidationErrorDetail_inputShapeNotSpecified, InstallValidationErrorDetail_integrationValidationError, InstallValidationErrorDetail_invalidBlockInstallationReference, InstallValidationErrorDetail_invalidNewInstallReference, InstallValidationErrorDetail_multipleInstallInstructionsWithSameKey, InstallValidationErrorDetail_newInstallationOfASingletonBlockSetThatIsAlreadyInstalled, InstallValidationErrorDetail_notAssociatedWithAnyBlockSetInstallation, InstallValidationErrorDetail_ontologyInstallLocationNotDefined, InstallValidationErrorDetail_outputShapeOverrideNotSupported, InstallValidationErrorDetail_resourceUsedAsBothInputAndOutput, InstallValidationErrorDetail_serializable, InstallValidationErrorDetail_shapeDoesNotExistOnBlock, InstallValidationErrorDetail_shapeValidationErrors, InstallValidationErrorDetail_upgradeOfASingletonBlockSetThatIsInstalledMultipleTimes, InstallableBlockSetInputGroups, InstallableBlockSetInputShape, InstallableBlockSetInputShapes, InstallableBlockSetOutputShape, InstallableBlockSetOutputShapes, InstallableBlockSetShapeDependencies, InstallableBlockSetVersionDocumentation, InstallableBlockSetVersionId, InstallableBlockSetVersionMetadata, InstallableBlockSetVersionShapes, InstallableInputBlockSetShapeMetadata, InstallableInputPreset, InstallablePresetResolvedShapeOverrides, InstallablePresetValue, InstallablePresetValue_fromSource, InstallablePresetValue_resolvedShapeOverrides, InstallableTransportBlock, InstallableTransportBlockSet, InstallationBuild, InstallationContextId, InstallationInstruction, InstallationInstruction_installExistingBlock, InstallationInstruction_installNewBlock, InstallationJobBuildAll, InstallationJobBuildOption, InstallationJobBuildOption_all, InstallationJobBuildOption_required, InstallationJobBuildRequired, InstallationJobValidationError, InstallationJobValidationErrorV2, InstallationJobValidationError_duplicateBlockSetVersionsInRequest, InstallationJobValidationError_externalRecommendationToSelf, InstallationJobValidationError_invalidNewBlockSetInstallationReferences, InstallationJobValidationError_invalidPreallocatedJobRid, InstallationJobValidationError_noInstallationsInRequest, InstallationJobValidationError_numberOfInstallationsInRequestLimitExceeded, InstallationJobValidationError_serializable, InstallationJobValidationError_unresolvableCycle, InstallationMode, InstallationMode_bootstrap, InstallationMode_production, InstallationMode_singleton, InstallationOutputKey, InstallationOutputKey_logicFunction, InstallationOutputKey_objectViewTab, InstallationOutputKey_ontologySdk, InstallationOutputKey_rid, InstallationOutputKey_rosettaDocsBundle, InstallationOutputMetadata, InstallationProductGroupMember, InstallationProjectRoleContext, InstallationResolvedInputShape, InstallationResolvedInputShapeFromDefault, InstallationResolvedInputShapeManuallyProvided, InstallationResolvedInputShapeValue, InstallationResolvedInputShapeValue_fromDefault, InstallationResolvedInputShapeValue_manuallyProvided, InstallationTimestamp, InsufficientPermissionsError, InsufficientPermissionsErrorUnion, InsufficientPermissionsErrorUnion_generic, InsufficientPermissionsErrorUnion_missingOperation, InsufficientPermissionsErrorUnion_notAuthorizedToDeclassify, InsufficientPermissionsErrorUnion_notAuthorizedToDeclassifyV2, InsufficientPermissionsErrorUnion_notAuthorizedToUseMarkings, InsufficientPermissionsErrorUnion_notAuthorizedToUseMarkingsV2, IntegerListType, IntegerType, IntegerValue, IntegerVersion, IntegrationCreateBlockVersionError, IntegrationCreateBlockVersionError_unknownError, InterfaceActionTypeConstraintApiName, InterfaceActionTypeConstraintIdentifier, InterfaceActionTypeConstraintIdentifier_rid, InterfaceActionTypeConstraintNotFound, InterfaceActionTypeConstraintReference, InterfaceActionTypeConstraintReferenceUnresolvable, InterfaceActionTypeConstraintRequiredMismatch, InterfaceActionTypeConstraintRid, InterfaceActionTypeConstraintRidIdentifier, InterfaceActionTypeConstraintShape, InterfaceLinkTypeApiName, InterfaceLinkTypeCardinality, InterfaceLinkTypeCardinalityMismatch, InterfaceLinkTypeIdentifier, InterfaceLinkTypeInputShape, InterfaceLinkTypeNotFound, InterfaceLinkTypeOutputShape, InterfaceLinkTypeReference, InterfaceLinkTypeRequiredMismatch, InterfaceLinkTypeRid, InterfaceObjectSetRidType, InterfaceParameterConstraintIdentifier, InterfaceParameterConstraintIdentifier_rid, InterfaceParameterConstraintReference, InterfaceParameterConstraintRequiredMismatch, InterfaceParameterConstraintRid, InterfaceParameterConstraintRidIdentifier, InterfaceParameterConstraintShape, InterfaceParameterConstraintTypeMismatch, InterfaceParameterPropertyValue, InterfacePropertySharedPropertyTypeReferenceMismatch, InterfacePropertyTypeApiName, InterfacePropertyTypeIdentifier, InterfacePropertyTypeInputShape, InterfacePropertyTypeNotFound, InterfacePropertyTypeOutputShape, InterfacePropertyTypeReference, InterfacePropertyTypeRequireImplementationMismatch, InterfacePropertyTypeRid, InterfaceReferenceListType, InterfaceReferenceType, InterfaceTypeApiName, InterfaceTypeIdentifier, InterfaceTypeIdentifier_rid, InterfaceTypeInputShape, InterfaceTypeOutputShape, InterfaceTypeReference, InterfaceTypeReferenceUnresolvable, InterfaceTypeRid, IntermediaryLinkLinkTypeReferenceMismatch, IntermediaryLinkLinkTypeReferenceUnresolvable, IntermediaryLinkLinkTypeSide, IntermediaryLinkObjectTypeMismatch, IntermediaryLinkObjectTypeReferenceUnresolvable, IntermediaryLinkObjectTypeSide, IntermediaryLinkTypeApiNames, InternalShapeId, InvalidBlockInstallationReference, InvalidBlockReference, InvalidCronExpression, InvalidInstallBlockSetsRequest, InvalidInstallBlocksRequest, InvalidInstallationProject, InvalidInstallationProjectReason, InvalidLinkedProduct, InvalidNewBlockSetInstallationReferences, InvalidNewInstallReference, InvalidZoneId, IssueRecallRequest, IssueRecallResponse, JobDraftMetadata, JobDraftOwnerValidationErrors, JobDraftOwnerValidationErrors_validationErrors, JobDraftOwnerValidationErrors_validationSummary, JobDraftOwnerValidationErrors_validations, JobDraftStatus, JobDraftStatus_idle, JobDraftStatus_resolving, JobDraftStatus_submitted, JobDraftStatus_submittingJob, JobDraftStatus_validating, JobDraftValidationErrorSummary, JobDraftValidationErrors, JobDraftValidationErrorsV2, JobRid, JobSettings, JobSpecEnvironmentIdentificationMethod, JobSpecEnvironmentIdentificationMethodV2, JobSpecRid, JobSubmissionFailure, JobSubmissionFailure_conflictingJobs, JobSubmittedResult, Jpeg2000Format, JpgFormat, KnownIdentifier, LanguageModelIdentifier, LanguageModelRid, LanguageModelShape, LasFormat, LastUpdatedTimestamp, LastUpgradeFailedConstraintFailure, LatestVersionPolicy, LegacyNotImplementedIdentifier, LibraryLocatorEnvironmentIdentificationMethod, LibraryLocatorEnvironmentIdentificationMethod_condaLocator, LibraryLocatorEnvironmentIdentificationMethod_condaLocatorV2, LicenseProductType, LinkTypeApiNames, LinkTypeApiNames_intermediary, LinkTypeApiNames_manyToMany, LinkTypeApiNames_oneToMany, LinkTypeId, LinkTypeIdResolver, LinkTypeIdentifier, LinkTypeIdentifier_id, LinkTypeIdentifier_rid, LinkTypeInputShape, LinkTypeInputShape_intermediary, LinkTypeInputShape_manyToMany, LinkTypeInputShape_oneToMany, LinkTypeIntermediaryShape, LinkTypeIntermediaryShapeDisplayMetadata, LinkTypeManyToManyInputShape, LinkTypeManyToManyOutputShape, LinkTypeManyToManyShapeDisplayMetadata, LinkTypeNotFound, LinkTypeOneToManyShape, LinkTypeOneToManyShapeDisplayMetadata, LinkTypeOutputShape, LinkTypeOutputShape_intermediary, LinkTypeOutputShape_manyToMany, LinkTypeOutputShape_oneToMany, LinkTypeReference, LinkTypeReferenceUnresolvable, LinkTypeRid, LinkTypeShapeDisplayMetadata, LinkTypeShapeDisplayMetadata_intermediary, LinkTypeShapeDisplayMetadata_manyToMany, LinkTypeShapeDisplayMetadata_oneToMany, LinkTypeType, LinkTypeUnexpected, LinkTypeUnknown, LinkedEntityTypeReference, LinkedEntityTypeReference_interfaceType, LinkedEntityTypeReference_objectType, LinkedInterfaceTypeReferenceMismatch, LinkedInterfaceTypeReferenceUnresolvable, LinkedObjectTypeReferenceMismatch, LinkedObjectTypeReferenceUnresolvable, Links, ListAvailableInstallLocationsResponse, ListBlockInstallationJobsResponseEntry, ListBlockInstallationJobsResponseV2, ListBlockInstallationJobsV2PageToken, ListBlockSetInstallationJobsPageToken, ListBlockSetInstallationJobsResponse, ListBlockSetInstallationsMetadataPageToken, ListBlockSetInstallationsMetadataResponse, ListBlockSetInstallationsResponseV2, ListBlockSetInstallationsV2PageToken, ListBlockSetVersionsPageToken, ListBlockSetVersionsResponse, ListBlockSetsPageToken, ListBlockSetsResponse, ListBlockSetsResponseEntry, ListDraftGroupsPageToken, ListDraftGroupsResponse, ListInstallableBlockSetVersionsByMavenProductIdResponse, ListInstallableBlockSetVersionsPageToken, ListInstallableBlockSetVersionsRequest, ListInstallableBlockSetVersionsResponse, ListJobDraftsForUserResponse, ListJobDraftsForUserResponseEntry, ListJobDraftsPageToken, ListPendingBlockSetVersionsPageToken, ListPendingBlockSetVersionsResponse, ListPendingBlockSetVersionsResponseEntry, ListProductVersionsPageToken, ListProductVersionsResponse, ListProductsPageToken, ListProductsReponseEntry, ListProductsResponse, ListSnapshotsForProductGroupPageToken, ListSnapshotsForProductGroupRequest, ListSnapshotsForProductGroupResponse, LocalMarketplaceDefinition, LocalMarketplaceNotFoundRationale, LocalTime, LocalUpstreamInstallationRecommendationSource, Locale, LocalizedDescription, LocalizedFreeFormDocumentationSections, LocalizedName, LocalizedNameField, LocalizedTitle, LocalizedTitleAndDescription, LocalizedTitleAndDescriptionOverride, LogicCreateBlockRequest, LogicFunctionId, LogicFunctionIdAndVersionIdentifier, LogicFunctionIdentifier, LogicFunctionIdentifier_idAndVersion, LogicFunctionShape, LogicFunctionShapeIdentifier, LogicFunctionVersion, LogicIdentifier, LogicInputArgument, LogicInputParameterType, LogicInputParameterType_unspecified, LogicOutputArgument, LogicOutputParameterType, LogicOutputParameterType_unspecified, LogicReference, LogicRid, LogicShape, LongListType, LongType, LongVersion, MachineryCreateBlockRequest, MachineryProcessIdentifier, MachineryProcessRid, MachineryProcessShape, MagritteApiName, MagritteConnectionId, MagritteConnectionIdentifier, MagritteConnectionInputShape, MagritteConnectionType, MagritteConnectorCreateBlockRequest, MagritteExportCreateBlockRequest, MagritteExportIdentifier, MagritteExportRid, MagritteExportShape, MagritteExtractOutputShape, MagritteExtractRid, MagritteExtractRidAndVersion, MagritteExtractVersionNumber, MagritteRequiredApiName, MagritteRequiredApiName_requireOriginalApiName, MagritteRequiredSecrets, MagritteRequiredSecrets_allSecrets, MagritteRequiredSecrets_requiredSecrets, MagritteSecretName, MagritteSourceConfigOverridesInputIdentifier, MagritteSourceConfigOverridesInputShape, MagritteSourceCreateBlockRequest, MagritteSourceIdentifier, MagritteSourceInputShape, MagritteSourceOutputShape, MagritteSourceReference, MagritteSourceRid, MagritteSourceType, MagritteSourceUsageRestriction, MagritteSourceUsageRestrictionName, MagritteSourceUsageRestriction_computeModule, MagritteSourceUsageRestriction_eddiePipeline, MagritteSourceUsageRestriction_stemmaRepository, MagritteStreamingExtractConfigOverridesInputIdentifier, MagritteStreamingExtractConfigOverridesInputShape, MagritteStreamingExtractOutputShape, MagritteStreamingExtractRid, MaintenanceWindow, MaintenanceWindows, ManagedBlockSetId, ManagedInstallationName, ManagedMarketplaceId, ManagedStoreAccessExpansion, ManagedStoreAccessExpansions, ManagedStoreAccessLevel, ManagedStoreAccessPrincipal, ManagedStoreAccessPrincipal_enrollment, ManagedStoreAccessPrincipal_organization, ManagedStoreBlockSetAccessExpansion, ManagedStoreBlockSetAccessLevel, ManagedStoreConfiguredSettingsEntry, ManagedStoreGroupConfiguration, ManagedStoreResponseEntry, ManagedStoreSettingsResponseEntry, MandatoryPresetNotUsed, ManifestOnlyBlockSpecificConfigurationV0, ManualProductGroupSnapshotTrigger, ManuallyProvidedInput, ManuallyProvidedInputV2, ManyToManyLinkTypeApiNames, MapRendererSetIdentifier, MapRendererSetIdentifierV2, MapRendererSetLocator, MapRendererSetLocator_interfaceTypeRid, MapRendererSetLocator_objectTypeRid, MapRendererSetOutputShape, MapRendererSetOutputShapeV2, MapRenderingServiceCreateBlockRequest, MapRenderingServiceLocator, MapRenderingServiceLocator_interfaceTypeRid, MapRenderingServiceLocator_objectTypeRid, MarkdownText, Marketplace, MarketplaceBulkResult, MarketplaceDefinition, MarketplaceDefinition_local, MarketplaceFoundrySearchSecurityRid, MarketplaceMetadataVersion, MarketplaceRid, MarkingId, MarkingListType, MarkingNotFound, MarkingOperation, MarkingResolver, MarkingSizeConstraintsNotSatisfied, MarkingType, MarkingTypeNotValid, MarkingTypeNotValidV2, MarkingTypeNotValidV3, MarkingsIdentifier, MarkingsShape, MarkingsSizeConstraints, MarkingsType, MaterializationBehavior, MaterializingBlockSetVersionStatus, MavenCoordinateDependency, MavenCoordinates, MavenGroup, MavenLocator, MavenProductId, MavenProductIdOrCoordinate, MediaReferenceListType, MediaReferenceType, MediaSchema, MediaSchemaType, MediaSchemaTypeV2, MediaSchemaTypeV2_any, MediaSchemaTypeV2_audio, MediaSchemaTypeV2_dicom, MediaSchemaTypeV2_document, MediaSchemaTypeV2_email, MediaSchemaTypeV2_imagery, MediaSchemaTypeV2_model3d, MediaSchemaTypeV2_multiModal, MediaSchemaTypeV2_spreadsheet, MediaSchemaTypeV2_streamingVideo, MediaSchemaTypeV2_video, MediaSchema_any, MediaSchema_document, MediaSchema_unspecified, MediaSetCreateBlockRequest, MediaSetDatasourceType, MediaSetLocator, MediaSetOutputSpecConfig, MediaSetTransactionPolicy, MediaSetTransactionPolicy_any, MediaSetTransactionPolicy_batchTransactions, MediaSetTransactionPolicy_noTransactions, MemberDependencyCycle, MeshId, MeshIdRemoteStrategy, MeshNodeLabel, MeshNodeLabelRemoteStrategy, MimeType, MissingCbacMarkingConstraint, MissingColumnTypeClass, MissingInternalRecommendationError, MissingOperationError, MissingRecommendation, MissingRecommendationShape, MkvVideoContainerFormat, Model3dDecodeFormat, Model3dDecodeFormat_las, Model3dDecodeFormat_obj, Model3dDecodeFormat_ply, Model3dSchema, Model3dType, ModelCreateBlockRequest, ModelInputIdentifier, ModelInputShape, ModelOutputIdentifier, ModelOutputShape, ModelOutputSpecConfig, ModelResourceShapeServiceMismatch, ModelResourceTypeMismatch, ModelRid, ModelStudioConfig, ModelStudioConfigIdentifier, ModelStudioConfigReference, ModelStudioConfigRid, ModelStudioConfigSelector, ModelStudioConfigShape, ModelStudioCreateBlockRequest, ModelStudioIdentifier, ModelStudioInputShape, ModelStudioOutputShape, ModelStudioOutputSpecConfig, ModelStudioReference, ModelStudioRid, ModelType, ModelTypeMismatch, ModelTypeMismatchV2, ModelTypeMismatchV3, ModelType_binary, ModelType_container, ModelType_modelSourceNotMarketplaceCompatible, ModelVersionRid, ModifyExistingBlockSetInstallation, ModifyJobDraftInstallationsRequest, ModifyJobDraftInstallationsResponse, MonitorIdentifier, MonitorShape, MonitorViewIdentifier, MonitorViewShape, MonitoringViewCreateBlockRequest, MonocleGraphIdentifier, MonocleGraphShape, MovVideoContainerFormat, MoveBlockSetInstallationsRequest, MoveBlockSetInstallationsResponse, Mp2Format, Mp3Format, Mp4AudioContainerFormat, Mp4AudioContainerFormat_singleStream, Mp4VideoContainerFormat, MultiModalSchema, MultipassGroupId, MultipassGroupResolver, MultipassGroupShape, MultipassUserAttributeName, MultipassUserAttributeShape, MultipassUserId, NameBasedDatasourceColumnIdentifier, NamedCredentialCreateBlockRequest, NamedCredentialIdentifier, NamedCredentialShape, NamespaceRid, NetworkEgressPolicyCreateBlockRequest, NetworkEgressPolicyIdentifier, NetworkEgressPolicyShape, NewAssociatedBlockSetInstallation, NewBlockSetInstallationId, NewInstallationOfSingletonBlockSetThatIsAlreadyInstalled, NewProject, NewProjectId, NewProjectOrExistingFolder, NewProjectOrExistingFolderV2, NewProjectOrExistingFolderV2_existingFolder, NewProjectOrExistingFolderV2_newProject, NewProjectOrExistingFolder_existingFolder, NewProjectOrExistingFolder_newProject, NewProjectV2, NistSphereFormat, NitfFormat, NoNewerVersionsOnReleaseChannelConstraintFailure, NonConstraintFailureNotificationCause, NonEmptyCompassInstallLocation, NormalizationMaxClassificationIdentifier, NormalizationMaxClassificationOutputShape, NormalizationMaxClassificationRid, NotAuthorizedToDeclassify, NotAuthorizedToDeclassifyError, NotAuthorizedToDeclassifyRationale, NotAuthorizedToUseMarkings, NotAuthorizedToUseMarkingsError, NotAuthorizedToUseMarkingsErrorV2, NotAuthorizedToUseMarkingsRationale, NotStartedInstallPendingStatus, NotepadCreateBlockRequest, NotepadDocumentShape, NotepadPartialResolvedShape, NotepadTemplateCreateBlockRequest, NotepadTemplateIdentifier, NotepadTemplateIdentifier_rid, NotepadTemplateIdentifier_ridAndVersion, NotepadTemplateParameterId, NotepadTemplateParameterIdAndTemplate, NotepadTemplateParameterIdentifier, NotepadTemplateParameterIdentifier_idAndTemplate, NotepadTemplateParameterReference, NotepadTemplateParameterShape, NotepadTemplateParameterType, NotepadTemplateParameterTypeMismatch, NotepadTemplateReference, NotepadTemplateRid, NotepadTemplateRidAndVersion, NotepadTemplateShape, NotepadTemplateVersion, NotificationCause, NotificationCause_constraintFailure, NotificationCause_nonConstraintFailureNotificationCause, NotificationMechanism, NotificationMechanismsTargets, NotificationRecipientUserId, NotificationScope, NotificationScope_user, NotificationType, NpmLocator, NumberOfInstallationsInRequestLimitExceeded, OacPermissionMetadata, OacSigningKeyEntry, ObjFormat, ObjectInstanceIdentifier, ObjectInstanceInputShape, ObjectInstanceNotFound, ObjectParameterPropertyValue, ObjectPropertyType, ObjectPropertyType_array, ObjectPropertyType_primitive, ObjectReferenceListType, ObjectReferenceType, ObjectRid, ObjectSetCreateBlockRequest, ObjectSetIdentifier, ObjectSetRid, ObjectSetRidType, ObjectSetShape, ObjectTypeApiName, ObjectTypeFieldApiName, ObjectTypeId, ObjectTypeIdentifier, ObjectTypeIdentifier_id, ObjectTypeIdentifier_rid, ObjectTypeInputShape, ObjectTypeInterfaceLinkImplementation, ObjectTypeNotFound, ObjectTypeOutputShape, ObjectTypeOutputSpecConfig, ObjectTypePropertyReference, ObjectTypeReference, ObjectTypeReferenceType, ObjectTypeReferenceUnresolvable, ObjectTypeRid, ObjectViewCreateBlockRequest, ObjectViewIdentifier, ObjectViewOutputSpecConfig, ObjectViewReference, ObjectViewShape, ObjectViewTabConfig, ObjectViewTabId, ObjectViewTabIdentifier, ObjectViewTabReference, ObjectViewTabShape, ObjectsBackendIncompatible, ObjectsBackendUnknown, OciLocator, OggAudioContainerFormat, OggAudioContainerFormat_singleStream, OggAudioFormat, OggAudioFormat_opus, OggAudioFormat_vorbis, OmittedShapeForShapeWithPresets, OneToManyLinkCardinalityHint, OneToManyLinkTypeApiNames, OntologyBoundFunctionApiName, OntologyBoundFunctionApiNameAndBinding, OntologyContext, OntologyCreateBlockRequest, OntologyDatasourceIdentifier, OntologyDatasourceMissingFromEntity, OntologyDatasourceNotFound, OntologyDatasourceRetentionShape, OntologyDatasourceShape, OntologyEntityNotInTargetOntology, OntologyEntityReference, OntologyEntityReference_manyToManyLinkType, OntologyEntityReference_objectType, OntologyInstallLocation, OntologyInstallLocationNotDefined, OntologyInterfaceTypeNotFound, OntologyPackageInDefaultOntologyNotAllowed, OntologyProjectAssociation, OntologyProjectAssociation_useOntologyPackage, OntologyProjectAssociation_useProject, OntologyRid, OntologySdkCreateBlockRequest, OntologySdkCreateBlockRequestV2, OntologySdkEntityIdentifier, OntologySdkIdentifier, OntologySdkRid, OntologySdkShape, OntologySdkShapeV2, OntologySdkV2EntityIdentifier, OntologySdkVersion, OntologyVersion, OpusFormat, OrExpressionIdentifier, OrderableMavenCoordinate, OrganizationRid, OtherStoreLocalRecommendationSource, OtherValidationFailure, OutputBlockSetMappingInfo, OutputBlockSetShapeId, OutputEditsSupport, OutputEditsSupportMismatch, OutputEntityIdentifier, OutputEntityIdentifier_action, OutputEntityIdentifier_actionParameter, OutputEntityIdentifier_aipAgent, OutputEntityIdentifier_appConfig, OutputEntityIdentifier_appConfigTitanium, OutputEntityIdentifier_artifactsRepository, OutputEntityIdentifier_authoringLibrary, OutputEntityIdentifier_authoringRepository, OutputEntityIdentifier_automation, OutputEntityIdentifier_autopilotWorkbench, OutputEntityIdentifier_blobster, OutputEntityIdentifier_carbonWorkspace, OutputEntityIdentifier_checkpointConfig, OutputEntityIdentifier_cipherChannel, OutputEntityIdentifier_cipherLicense, OutputEntityIdentifier_codeWorkspace, OutputEntityIdentifier_compassResource, OutputEntityIdentifier_contourAnalysis, OutputEntityIdentifier_contourRef, OutputEntityIdentifier_dataHealthCheck, OutputEntityIdentifier_dataHealthCheckGroup, OutputEntityIdentifier_datasourceColumn, OutputEntityIdentifier_deployedApp, OutputEntityIdentifier_eddieEdgePipeline, OutputEntityIdentifier_eddiePipeline, OutputEntityIdentifier_evaluationSuite, OutputEntityIdentifier_filesDatasource, OutputEntityIdentifier_function, OutputEntityIdentifier_functionConfiguration, OutputEntityIdentifier_functionPackageConfiguration, OutputEntityIdentifier_geotimeSeriesIntegration, OutputEntityIdentifier_interfaceActionTypeConstraint, OutputEntityIdentifier_interfaceLinkType, OutputEntityIdentifier_interfaceParameterConstraint, OutputEntityIdentifier_interfacePropertyType, OutputEntityIdentifier_interfaceType, OutputEntityIdentifier_link, OutputEntityIdentifier_logic, OutputEntityIdentifier_logicFunction, OutputEntityIdentifier_machinery, OutputEntityIdentifier_magritteExport, OutputEntityIdentifier_magritteExtract, OutputEntityIdentifier_magritteSource, OutputEntityIdentifier_magritteStreamingExtract, OutputEntityIdentifier_mapRendererSet, OutputEntityIdentifier_mapRendererSetV2, OutputEntityIdentifier_model, OutputEntityIdentifier_modelStudio, OutputEntityIdentifier_modelStudioConfig, OutputEntityIdentifier_monitor, OutputEntityIdentifier_monitorView, OutputEntityIdentifier_namedCredential, OutputEntityIdentifier_networkEgressPolicy, OutputEntityIdentifier_normalizationMaxClassification, OutputEntityIdentifier_notepadDocument, OutputEntityIdentifier_notepadTemplate, OutputEntityIdentifier_notepadTemplateParameter, OutputEntityIdentifier_objectSet, OutputEntityIdentifier_objectType, OutputEntityIdentifier_objectView, OutputEntityIdentifier_objectViewTab, OutputEntityIdentifier_ontologyDatasource, OutputEntityIdentifier_ontologySdk, OutputEntityIdentifier_ontologySdkV2, OutputEntityIdentifier_peerProducerProfile, OutputEntityIdentifier_peerProfile, OutputEntityIdentifier_property, OutputEntityIdentifier_quiverDashboard, OutputEntityIdentifier_resourceUpdatesContent, OutputEntityIdentifier_rosettaDocsBundle, OutputEntityIdentifier_savedSearchAroundV2, OutputEntityIdentifier_schedule, OutputEntityIdentifier_sharedPropertyType, OutputEntityIdentifier_slateApplication, OutputEntityIdentifier_solutionDesign, OutputEntityIdentifier_sqlWorksheet, OutputEntityIdentifier_storedProcedure, OutputEntityIdentifier_tabularDatasource, OutputEntityIdentifier_taurusWorkflow, OutputEntityIdentifier_thirdPartyApplication, OutputEntityIdentifier_timeSeriesSync, OutputEntityIdentifier_transformsJobSpec, OutputEntityIdentifier_valueType, OutputEntityIdentifier_versionedObjectSet, OutputEntityIdentifier_vertexTemplate, OutputEntityIdentifier_vortexTemplate, OutputEntityIdentifier_walkthrough, OutputEntityIdentifier_webhook, OutputEntityIdentifier_widget, OutputEntityIdentifier_widgetSet, OutputEntityIdentifier_workbenchTemplate, OutputEntityIdentifier_workflowBuilderGraph, OutputEntityIdentifier_workflowGraph, OutputEntityIdentifier_workshop, OutputLinkTypeIdentifier, OutputObjectBackendVersion, OutputObjectTypeIdentifier, OutputObjectsBackendMismatch, OutputOwnedByAnotherInstallation, OutputReference, OutputShape, OutputShapeCleanupPreview, OutputShapeDependencies, OutputShapeOverrideNotSupported, OutputShapeResult, OutputShapeType, OutputShapeUninstallPreview, OutputShape_action, OutputShape_actionParameter, OutputShape_aipAgent, OutputShape_appConfig, OutputShape_appConfigTitanium, OutputShape_artifactsRepository, OutputShape_authoringLibrary, OutputShape_authoringRepository, OutputShape_automation, OutputShape_autopilotWorkbench, OutputShape_blobsterResource, OutputShape_carbonWorkspace, OutputShape_checkpointConfig, OutputShape_cipherChannel, OutputShape_cipherLicense, OutputShape_codeWorkspace, OutputShape_compassResource, OutputShape_contourAnalysis, OutputShape_contourRef, OutputShape_dataHealthCheck, OutputShape_dataHealthCheckGroup, OutputShape_datasourceColumn, OutputShape_deployedApp, OutputShape_eddieEdgePipeline, OutputShape_eddiePipeline, OutputShape_evaluationSuite, OutputShape_filesDatasource, OutputShape_function, OutputShape_functionConfiguration, OutputShape_functionPackageConfiguration, OutputShape_geotimeSeriesIntegration, OutputShape_interfaceActionTypeConstraint, OutputShape_interfaceLinkType, OutputShape_interfaceParameterConstraint, OutputShape_interfacePropertyType, OutputShape_interfaceType, OutputShape_linkType, OutputShape_logic, OutputShape_logicFunction, OutputShape_machinery, OutputShape_magritteExport, OutputShape_magritteExtract, OutputShape_magritteSource, OutputShape_magritteStreamingExtract, OutputShape_mapRendererSet, OutputShape_mapRendererSetV2, OutputShape_model, OutputShape_modelStudio, OutputShape_modelStudioConfig, OutputShape_monitor, OutputShape_monitorView, OutputShape_namedCredential, OutputShape_networkEgressPolicy, OutputShape_normalizationMaxClassification, OutputShape_notepadDocument, OutputShape_notepadTemplate, OutputShape_notepadTemplateParameter, OutputShape_objectSet, OutputShape_objectType, OutputShape_objectView, OutputShape_objectViewTab, OutputShape_ontologyDatasource, OutputShape_ontologySdk, OutputShape_ontologySdkV2, OutputShape_peerProducerProfile, OutputShape_peerProfile, OutputShape_property, OutputShape_quiverDashboard, OutputShape_resourceUpdatesContent, OutputShape_rosettaDocsBundle, OutputShape_savedSearchAroundV2, OutputShape_schedule, OutputShape_sharedPropertyType, OutputShape_slateApplication, OutputShape_solutionDesign, OutputShape_sqlWorksheet, OutputShape_storedProcedure, OutputShape_tabularDatasource, OutputShape_taurusWorkflow, OutputShape_thirdPartyApplication, OutputShape_timeSeriesSync, OutputShape_transformsJobSpec, OutputShape_valueType, OutputShape_versionedObjectSet, OutputShape_vertexTemplate, OutputShape_vortexTemplate, OutputShape_walkthrough, OutputShape_webhook, OutputShape_widget, OutputShape_widgetSet, OutputShape_workbenchTemplate, OutputShape_workflowBuilderGraph, OutputShape_workflowGraph, OutputShape_workshopApplication, OutputSpec, OutputSpecConfig, OutputSpecConfigType, OutputSpecConfig_appConfigConfig, OutputSpecConfig_authoringRepositoryConfig, OutputSpecConfig_automationConfig, OutputSpecConfig_cipherChannelConfig, OutputSpecConfig_cipherLicenseConfig, OutputSpecConfig_computeModuleConfig, OutputSpecConfig_contourConfig, OutputSpecConfig_datasetConfig, OutputSpecConfig_eddiePipelineConfig, OutputSpecConfig_mediaSetConfig, OutputSpecConfig_modelConfig, OutputSpecConfig_modelStudioConfig, OutputSpecConfig_objectTypeConfig, OutputSpecConfig_objectViewConfig, OutputSpecError, OutputSpecErrors, OutputSpecErrors_errors, OutputSpecErrors_insufficientPermissions, OutputSpecInsufficientPermissionsError, OutputSpecProvenance, OutputSpecProvenance_dependency, OutputSpecProvenance_discovered, OutputSpecProvenance_explicit, OutputSpecProvenance_inferredFolderStructure, OutputSpecResult, OutsideMaintenanceWindowsConstraintFailure, OverlappingRecommendation, OverlappingRecommendations, OverriddenMetadataFromStartingVersion, OverriddenOutputSpecs, OverrideOntologyEntityApiNamesShape, OwnedBlockMetadata, OwnedPendingRecommendationSource, PackageName, PackagingLogicVersion, PackagingSettings, PageSizeLimitHint, ParameterAndAction, ParameterInputShape, ParameterPartialResolvedShape, PartiallyDeletedInstallationRationale, PartiallyResolvedOutputSpec, PathPolicy, PathPolicy_any, PathPolicy_pathNotSupported, PathPolicy_pathRequired, PdfFormat, PeerProducerProfileIdentifier, PeerProducerProfileRid, PeerProducerProfileShape, PeerProfileCreateBlockRequest, PeerProfileIdentifier, PeerProfileRemoteStrategyIdentifier, PeerProfileRemoteStrategyMismatch, PeerProfileRemoteStrategyShape, PeerProfileRemoteStrategyType, PeerProfileRid, PeerProfileShape, PendingBlockSetInputShapes, PendingBlockSetOutputShapes, PendingBlockSetVersionMetadata, PendingBuildInstallPendingStatus, PendingInputBlockSetMappingInfo, PendingOutputBlockSetMappingInfo, PendingRecommendationStatus, PendingRecommendationStatus_complete, PendingRecommendationStatus_processing, PermanentlyDeleteUninstallOptions, PinnedMediaSetView, PinnedVersionPolicy, PlaceholdersLocation, PlainTextTypeUnsupported, PlyFormat, PngFormat, PortConfig, PostInstallationBuildMetadata, PostInstallationJobTask, PostInstallationJobTask_buildMetadata, PotentialInputProvider, PptxFormat, PreallocateAccessRequirementType, PreallocatingInstallPendingStatus, PreserveFunctionVersionsConfiguration, PresetEnforcement, PresetFromSource, PresetResolutionFailedError, PresetResolvedShapeOverrides, PresetValue, PresetValue_fromSource, PresetValue_resolvedShapeOverrides, PreviewCleanupUnusedShapesResponse, PreviewDiscoveryRequest, PreviewDiscoveryResponse, PreviewDiscoveryResult, PreviewUninstallResponse, PrimitiveBaseType, PrimitiveBaseType_binary, PrimitiveBaseType_boolean, PrimitiveBaseType_byte, PrimitiveBaseType_date, PrimitiveBaseType_decimal, PrimitiveBaseType_double, PrimitiveBaseType_float, PrimitiveBaseType_integer, PrimitiveBaseType_long, PrimitiveBaseType_map, PrimitiveBaseType_optional, PrimitiveBaseType_short, PrimitiveBaseType_string, PrimitiveBaseType_struct, PrimitiveBaseType_structV2, PrimitiveBaseType_timestamp, PrimitiveObjectPropertyType, PrimitiveObjectPropertyType_attachmentType, PrimitiveObjectPropertyType_booleanType, PrimitiveObjectPropertyType_byteType, PrimitiveObjectPropertyType_cipherTextType, PrimitiveObjectPropertyType_dateType, PrimitiveObjectPropertyType_decimalType, PrimitiveObjectPropertyType_doubleType, PrimitiveObjectPropertyType_floatType, PrimitiveObjectPropertyType_geohashType, PrimitiveObjectPropertyType_geoshapeType, PrimitiveObjectPropertyType_geotimeSeriesReferenceType, PrimitiveObjectPropertyType_integerType, PrimitiveObjectPropertyType_longType, PrimitiveObjectPropertyType_markingType, PrimitiveObjectPropertyType_mediaReferenceType, PrimitiveObjectPropertyType_shortType, PrimitiveObjectPropertyType_stringType, PrimitiveObjectPropertyType_structType, PrimitiveObjectPropertyType_timeDependentType, PrimitiveObjectPropertyType_timestampType, PrimitiveObjectPropertyType_vectorType, Principal, PrincipalId, PrincipalType, ProcessingStatus, ProcessingStatusV3, ProducerUri, ProductDisplayVersion, ProductGroup, ProductGroupMemberRid, ProductGroupMemberSpec, ProductGroupMemberSpec_blockSet, ProductGroupMemberSpec_installation, ProductGroupRid, ProductGroupSnapshot, ProductGroupSnapshotDetails, ProductGroupSnapshotRid, ProductGroupSnapshotTrigger, ProductGroupSnapshotTrigger_manual, ProductGroupValidationFinding, ProductGroupValidationFindingDetail, ProductGroupValidationFindingDetail_duplicateOutputs, ProductGroupValidationFindingDetail_incompatibleExternalRecommendationVersionRange, ProductGroupValidationFindingDetail_memberDependencyCycle, ProductGroupValidationFindingDetail_missingRecommendation, ProductGroupValidationFindingDetail_overlappingRecommendations, ProductGroupValidationFindingDetail_unfulfilledInput, ProductGroupValidationFindingLevel, ProductGroupValidationFindingRid, ProductGroupValidationSettings, ProductGroupValidationStatus, ProductGroupValidationStatus_error, ProductGroupValidationStatus_valid, ProductGroupValidationStatus_warn, ProductGroupVersionRid, ProductId, ProductInstallationMode, ProductType, ProductVersionId, ProductVersionMetadata, ProductVersionStatus, ProfileFamilyConstraint, ProjectContext, ProjectMutabilityCapabilities, PropertyAndObject, PropertyIdentifier, PropertyIdentifier_propertyAndObject, PropertyInputShape, PropertyOutputShape, PropertyTypeId, PropertyTypeMismatch, PropertyTypeNotFound, PropertyTypeRid, PropertyTypeRidOrId, PropertyTypeRidOrId_id, PropertyTypeRidOrId_rid, PropertyTypeUnknown, ProposedBlockInstallLocation, ProposedCompassInstallLocation, PutCategoryRequest, PutMarketplaceMetadataRequest, PutTagRequest, PypiLocator, QuiverCreateBlockRequest, QuiverDashboardIdentifier, QuiverDashboardShape, RateLimitedRequestPermit, RecallId, RecallVersionsAnnouncement, RecommendationBlockReference, RecommendationBlockSetReference, RecommendationEntryBody, RecommendationEntryBody_actionType, RecommendationEntryBody_simple, ReconcileAccessRequirementType, ReconcilingInstallPendingStatus, RefreshSpecsConfig, RefreshSpecsConfig_refreshAll, RefreshSpecsConfig_refreshDiscovery, RefreshSpecsConfig_refreshMaterialization, RefreshSpecsConfig_refreshNone, RefreshSpecsConfig_refreshSubset, RegisterInstallationRequest, RegisterInstallationResponse, RegisterKeyRequest, RegisterKeyResponse, ReleaseChannel, ReleaseChannelVersionPolicy, ReleaseRid, RemoveFromDraftGroupRequest, RepoDataLocator, RepositorySourceCodePackagingType, RequestType, RequiredActionParameterTypeShapeMissing, ResolveMemberSourceRequest, ResolveMemberSourceResponse, ResolvePresetsRequest, ResolvePresetsResponse, ResolvePresetsTargetInstallLocation, ResolvedActionTypeParameterShape, ResolvedActionTypeReferenceMismatch, ResolvedActionTypeShape, ResolvedAipAgentShape, ResolvedAllowOntologySchemaMigrationsShape, ResolvedAuthoringLibraryShape, ResolvedAutomationShape, ResolvedBlockSetInputGroup, ResolvedBlockSetInputOrRef, ResolvedBlockSetInputOrRef_automapped, ResolvedBlockSetInputOrRef_fromDefault, ResolvedBlockSetInputOrRef_referenceExistingOutputInStore, ResolvedBlockSetInputOrRef_referenceOtherOutput, ResolvedBlockSetInputOrRef_resolvedInputShape, ResolvedBlockSetInputShape, ResolvedBlockSetOutputShape, ResolvedCipherLicenseShape, ResolvedCodeWorkspaceInputShape, ResolvedCodeWorkspaceLicenseInputShape, ResolvedCodeWorkspaceOutputShape, ResolvedContourAnalysisShape, ResolvedContourRefShape, ResolvedDatasourceColumnShape, ResolvedDatasourceShape, ResolvedEddieEdgeParameterShape, ResolvedEddieEdgePipelineOutputShape, ResolvedEddieGeotimeConfigurationInputShape, ResolvedEddieParameter, ResolvedEddieParameterShape, ResolvedEddieParameterShapeV2, ResolvedEddieParameter_primitive, ResolvedEddiePrimitiveParameter, ResolvedEddiePrimitiveParameter_enum, ResolvedEddiePrimitiveParameter_literal, ResolvedEddiePrimitiveParameter_regex, ResolvedEddieReplayOption, ResolvedEddieReplayOptionShape, ResolvedEddieReplayOption_acknowledgeStateBreaks, ResolvedEddieReplayOption_reset, ResolvedEddieReplayOption_resetAndReplayFromOffset, ResolvedEdgePipelineMagritteSourceInputShape, ResolvedFilesDatasourceShape, ResolvedFlinkProfile, ResolvedFunctionConfigurationShape, ResolvedFunctionContractShape, ResolvedFunctionInputShape, ResolvedFunctionOutputShape, ResolvedFunctionPackageCandidateLocator, ResolvedFunctionPackageConfigurationShape, ResolvedFunctionPackageLocator, ResolvedFunctionPackageLocator_candidateFunction, ResolvedFunctionVersionsConfigurationInputShape, ResolvedFunctionsApiStabilityConfigurationInputShape, ResolvedGeotimeSeriesIntegrationShape, ResolvedInputGroup, ResolvedInputOrRef, ResolvedInputOrRef_referenceExistingOutputInStore, ResolvedInputOrRef_referenceOtherOutput, ResolvedInputOrRef_resolvedInputShape, ResolvedInputShape, ResolvedInputShape_action, ResolvedInputShape_actionParameter, ResolvedInputShape_aipAgent, ResolvedInputShape_allowOntologySchemaMigrations, ResolvedInputShape_artifactsRepository, ResolvedInputShape_authoringLibrary, ResolvedInputShape_authoringRepository, ResolvedInputShape_automation, ResolvedInputShape_autopilotWorkbench, ResolvedInputShape_blobsterResource, ResolvedInputShape_carbonWorkspace, ResolvedInputShape_cipherChannel, ResolvedInputShape_cipherLicense, ResolvedInputShape_cipherLicenseV2, ResolvedInputShape_codeWorkspace, ResolvedInputShape_codeWorkspaceLicense, ResolvedInputShape_compassResource, ResolvedInputShape_contourAnalysis, ResolvedInputShape_contourRef, ResolvedInputShape_dataHealthCheck, ResolvedInputShape_dataHealthCheckGroup, ResolvedInputShape_datasourceColumn, ResolvedInputShape_deployedApp, ResolvedInputShape_eddieEdgeParameter, ResolvedInputShape_eddieGeotimeConfiguration, ResolvedInputShape_eddieParameter, ResolvedInputShape_eddieParameterV2, ResolvedInputShape_eddiePipeline, ResolvedInputShape_eddieReplayOption, ResolvedInputShape_edgePipelineMagritteSource, ResolvedInputShape_evaluationSuite, ResolvedInputShape_filesDatasource, ResolvedInputShape_flinkProfile, ResolvedInputShape_function, ResolvedInputShape_functionContract, ResolvedInputShape_functionVersionsConfiguration, ResolvedInputShape_functionsApiStabilityConfiguration, ResolvedInputShape_fusionDocument, ResolvedInputShape_geotimeSeriesIntegration, ResolvedInputShape_installPrefix, ResolvedInputShape_interfaceActionTypeConstraint, ResolvedInputShape_interfaceLinkType, ResolvedInputShape_interfaceParameterConstraint, ResolvedInputShape_interfacePropertyType, ResolvedInputShape_interfaceType, ResolvedInputShape_languageModel, ResolvedInputShape_linkType, ResolvedInputShape_logic, ResolvedInputShape_logicFunction, ResolvedInputShape_machinery, ResolvedInputShape_magritteConnection, ResolvedInputShape_magritteExport, ResolvedInputShape_magritteSource, ResolvedInputShape_magritteSourceConfigOverrides, ResolvedInputShape_magritteStreamingExtractConfigOverrides, ResolvedInputShape_markings, ResolvedInputShape_model, ResolvedInputShape_modelStudio, ResolvedInputShape_monitorView, ResolvedInputShape_monocleGraph, ResolvedInputShape_multipassGroup, ResolvedInputShape_multipassUserAttribute, ResolvedInputShape_namedCredential, ResolvedInputShape_networkEgressPolicy, ResolvedInputShape_notepadDocument, ResolvedInputShape_notepadTemplate, ResolvedInputShape_notepadTemplateParameter, ResolvedInputShape_objectInstance, ResolvedInputShape_objectSet, ResolvedInputShape_objectType, ResolvedInputShape_objectView, ResolvedInputShape_objectViewTab, ResolvedInputShape_ontologyDatasource, ResolvedInputShape_ontologyDatasourceRetention, ResolvedInputShape_ontologySdk, ResolvedInputShape_overrideOntologyEntityApiNames, ResolvedInputShape_parameter, ResolvedInputShape_peerProducerProfile, ResolvedInputShape_peerProfile, ResolvedInputShape_peerProfileRemoteStrategy, ResolvedInputShape_property, ResolvedInputShape_quiverDashboard, ResolvedInputShape_schedule, ResolvedInputShape_sharedPropertyType, ResolvedInputShape_slateApplication, ResolvedInputShape_solutionDesign, ResolvedInputShape_sparkProfile, ResolvedInputShape_sqlWorksheet, ResolvedInputShape_storedProcedure, ResolvedInputShape_tabularDatasource, ResolvedInputShape_taurusWorkflow, ResolvedInputShape_thirdPartyApplication, ResolvedInputShape_timeSeriesSync, ResolvedInputShape_valueType, ResolvedInputShape_vectorWorkbook, ResolvedInputShape_versionedObjectSet, ResolvedInputShape_vertexTemplate, ResolvedInputShape_vortexTemplate, ResolvedInputShape_walkthrough, ResolvedInputShape_webhook, ResolvedInputShape_widget, ResolvedInputShape_widgetSet, ResolvedInputShape_workbenchTemplate, ResolvedInputShape_workflowBuilderGraph, ResolvedInputShape_workflowGraph, ResolvedInputShape_workshopApplication, ResolvedInputShape_workshopApplicationSaveLocation, ResolvedInstallPrefixShape, ResolvedInstallation, ResolvedInterfaceActionTypeConstraintReferenceMismatch, ResolvedInterfaceActionTypeConstraintShape, ResolvedInterfaceLinkTypeShape, ResolvedInterfaceParameterConstraintShape, ResolvedInterfacePropertyTypeShape, ResolvedInterfaceTypeReferenceMismatch, ResolvedInterfaceTypeShape, ResolvedIntermediaryLinkOntologyTypes, ResolvedIntermediaryLinkOntologyTypesInconsistent, ResolvedJobDraft, ResolvedLanguageModelShape, ResolvedLinkTypeInputShape, ResolvedLinkTypeOutputShape, ResolvedLinkTypeReferenceMismatch, ResolvedLinkedObjectTypesUnknown, ResolvedLinkedOntologyTypes, ResolvedLinkedOntologyTypes_intermediary, ResolvedLinkedOntologyTypes_manyToMany, ResolvedLinkedOntologyTypes_oneToMany, ResolvedLogicFunctionShape, ResolvedMachineryProcessShape, ResolvedMagritteConnectionInputShape, ResolvedMagritteExportShape, ResolvedMagritteExtractOutputShape, ResolvedMagritteSourceConfigOverridesInputShape, ResolvedMagritteSourceInputShape, ResolvedMagritteSourceOutputShape, ResolvedMagritteStreamingExtractConfigOverridesInputShape, ResolvedMagritteStreamingExtractOutputShape, ResolvedManyToManyLinkObjectTypes, ResolvedManyToManyLinkObjectTypesInconsistent, ResolvedMapRendererSetOutputShape, ResolvedMapRendererSetOutputShapeV2, ResolvedMarkingsShape, ResolvedModelInputShape, ResolvedModelOutputShape, ResolvedModelStudioConfigShape, ResolvedMultipassGroupShape, ResolvedMultipassUserAttributeShape, ResolvedNotepadTemplateParameterShape, ResolvedNotepadTemplateShape, ResolvedObjectInstanceShape, ResolvedObjectSetShape, ResolvedObjectTypeReferenceMismatch, ResolvedObjectTypeShape, ResolvedObjectViewShape, ResolvedObjectViewTabShape, ResolvedOneToManyLinkObjectTypes, ResolvedOneToManyLinkObjectTypesInconsistent, ResolvedOntologyDatasourceRetentionShape, ResolvedOntologyDatasourceShape, ResolvedOntologySdkShape, ResolvedOntologySdkShapeV2, ResolvedOutputShape, ResolvedOutputShapeAttachedMultipleTimes, ResolvedOutputShape_action, ResolvedOutputShape_actionParameter, ResolvedOutputShape_aipAgent, ResolvedOutputShape_appConfig, ResolvedOutputShape_appConfigTitanium, ResolvedOutputShape_artifactsRepository, ResolvedOutputShape_authoringLibrary, ResolvedOutputShape_authoringRepository, ResolvedOutputShape_automation, ResolvedOutputShape_autopilotWorkbench, ResolvedOutputShape_blobsterResource, ResolvedOutputShape_carbonWorkspace, ResolvedOutputShape_checkpointConfig, ResolvedOutputShape_cipherChannel, ResolvedOutputShape_cipherLicense, ResolvedOutputShape_codeWorkspace, ResolvedOutputShape_compassResource, ResolvedOutputShape_contourAnalysis, ResolvedOutputShape_contourRef, ResolvedOutputShape_dataHealthCheck, ResolvedOutputShape_dataHealthCheckGroup, ResolvedOutputShape_datasourceColumn, ResolvedOutputShape_deployedApp, ResolvedOutputShape_eddieEdgePipeline, ResolvedOutputShape_eddiePipeline, ResolvedOutputShape_evaluationSuite, ResolvedOutputShape_filesDatasource, ResolvedOutputShape_function, ResolvedOutputShape_functionConfiguration, ResolvedOutputShape_functionPackageConfiguration, ResolvedOutputShape_geotimeSeriesIntegration, ResolvedOutputShape_interfaceActionTypeConstraint, ResolvedOutputShape_interfaceLinkType, ResolvedOutputShape_interfaceParameterConstraint, ResolvedOutputShape_interfacePropertyType, ResolvedOutputShape_interfaceType, ResolvedOutputShape_linkType, ResolvedOutputShape_logic, ResolvedOutputShape_logicFunction, ResolvedOutputShape_machinery, ResolvedOutputShape_magritteExport, ResolvedOutputShape_magritteExtract, ResolvedOutputShape_magritteSource, ResolvedOutputShape_magritteStreamingExtract, ResolvedOutputShape_mapRendererSet, ResolvedOutputShape_mapRendererSetV2, ResolvedOutputShape_model, ResolvedOutputShape_modelStudio, ResolvedOutputShape_modelStudioConfig, ResolvedOutputShape_monitor, ResolvedOutputShape_monitorView, ResolvedOutputShape_namedCredential, ResolvedOutputShape_networkEgressPolicy, ResolvedOutputShape_normalizationMaxClassification, ResolvedOutputShape_notepadDocument, ResolvedOutputShape_notepadTemplate, ResolvedOutputShape_notepadTemplateParameter, ResolvedOutputShape_objectSet, ResolvedOutputShape_objectType, ResolvedOutputShape_objectView, ResolvedOutputShape_objectViewTab, ResolvedOutputShape_ontologyDatasource, ResolvedOutputShape_ontologySdk, ResolvedOutputShape_ontologySdkV2, ResolvedOutputShape_peerProducerProfile, ResolvedOutputShape_peerProfile, ResolvedOutputShape_property, ResolvedOutputShape_quiverDashboard, ResolvedOutputShape_resourceUpdatesContent, ResolvedOutputShape_rosettaDocsBundle, ResolvedOutputShape_savedSearchAroundV2, ResolvedOutputShape_schedule, ResolvedOutputShape_sharedPropertyType, ResolvedOutputShape_slateApplication, ResolvedOutputShape_solutionDesign, ResolvedOutputShape_sqlWorksheet, ResolvedOutputShape_storedProcedure, ResolvedOutputShape_tabularDatasource, ResolvedOutputShape_taurusWorkflow, ResolvedOutputShape_thirdPartyApplication, ResolvedOutputShape_timeSeriesSync, ResolvedOutputShape_transformsJobSpec, ResolvedOutputShape_valueType, ResolvedOutputShape_versionedObjectSet, ResolvedOutputShape_vertexTemplate, ResolvedOutputShape_vortexTemplate, ResolvedOutputShape_walkthrough, ResolvedOutputShape_webhook, ResolvedOutputShape_widget, ResolvedOutputShape_widgetSet, ResolvedOutputShape_workbenchTemplate, ResolvedOutputShape_workflowBuilderGraph, ResolvedOutputShape_workflowGraph, ResolvedOutputShape_workshopApplication, ResolvedOutputSpec, ResolvedOutputSpecAndProvenance, ResolvedOutputSpecConfig, ResolvedOutputSpecConfig_config, ResolvedOutputSpecConfig_notConfigurable, ResolvedOutputSpecVersion, ResolvedOutputSpecVersion_unversioned, ResolvedOutputSpecVersion_version, ResolvedOverrideOntologyEntityApiNamesShape, ResolvedParameterInputShape, ResolvedPeerProducerProfileShape, ResolvedPeerProfileRemoteStrategyShape, ResolvedPeerProfileRemoteStrategyShape_meshId, ResolvedPeerProfileRemoteStrategyShape_meshNodeLabel, ResolvedPeerProfileRemoteStrategyShape_specificRemote, ResolvedPresetValue, ResolvedPresetValue_fromSource, ResolvedPresetValue_resolvedShapeOverrides, ResolvedProductGroupMember, ResolvedPropertyShape, ResolvedQuiverDashboardShape, ResolvedRosettaDocsBundleShape, ResolvedSavedSearchAroundV2OutputShape, ResolvedScheduleShape, ResolvedShapeOverridesResolvedPresetValue, ResolvedShapeResolutionFailure, ResolvedShapeResolutionResultUnion, ResolvedShapeResolutionResultUnion_resolutionFailure, ResolvedShapeResolutionResultUnion_resolutionSuccess, ResolvedShapeResolutionSuccess, ResolvedSharedPropertyTypeReferenceMismatch, ResolvedSharedPropertyTypeShape, ResolvedSolutionDesignShape, ResolvedSparkProfile, ResolvedSqlWorksheetShape, ResolvedStoredProcedureShape, ResolvedThirdPartyApplicationShape, ResolvedTimeSeriesSyncShape, ResolvedValueTypeShape, ResolvedVersionedObjectSetShape, ResolvedVertexTemplateShape, ResolvedVortexTemplateShape, ResolvedWalkthroughShape, ResolvedWebhookInputShape, ResolvedWebhookOutputShape, ResolvedWidgetSetShape, ResolvedWidgetShape, ResolvedWorkshopApplicationSaveLocationInputShape, ResourceInstallationProvenanceResponse, ResourceIsNotProject, ResourcePermissionDenied, ResourceType, ResourceUpdatesContentIdentifier, ResourceUpdatesContentOutputShape, ResourceUpdatesCreateBlockRequest, ResourceUsedAsBothInputAndOutput, ResourceVersion, ResourceVersionType, ResourceVersion_integer, ResourceVersion_long, ResourceVersion_rid, ResourceVersion_semver, ResourceVersion_string, ResourceVersion_uuid, RestrictedViewCreateBlockRequest, RestrictedViewLocator, RestrictedViewLocatorIdentifier, RidFilter, RidResolvedShape, RidShapeIdentifier, RidVersion, RoleGrant, RoleId, RoleSetId, RollForwardStrategy, RollOffStrategy, RollOffStrategy_rollForward, RosettaCreateBlockRequest, RosettaDocsBundleIdentifier, RosettaDocsBundleSecurityRid, RosettaDocsBundleShape, RosettaProductId, RtfFormat, SatelliteImageryModelCreateBlockRequest, SavedSearchAroundV2CreateBlockRequest, SavedSearchAroundV2OutputIdentifier, SavedSearchAroundV2OutputShape, ScenarioReferenceType, ScheduleCreateBlockRequest, ScheduleIdentifier, ScheduleRid, ScheduleSecurityRid, ScheduleShape, ScheduleShapeInvalid, ScheduleShapeInvalid_scheduleVersionInvalid, ScheduleVersionInvalid, SecretKey, SecretName, SemverVersion, SemverVersionComponent, SerializableCreateBlockVersionError, SerializedDataLocator, SerializedDataLocator_conda, SerializedDataLocator_condaV2, SerializedDataLocator_files, SerializedDataLocator_maven, SerializedDataLocator_npm, SerializedDataLocator_oci, SerializedDataLocator_pypi, SerializedDataLocator_repoData, ServiceManagedValueTypeIdentifier, ServiceName, SetBlockSetInstallationImmutabilityRequest, SetBlockSetInstallationImmutabilityResponse, SetInputPresetRequest, SetInputPresetValueRequest, SetInputPresetValueRequest_fromSource, SetInputPresetValueRequest_resolvedShapeOverrides, SetInstallAutomationSettingsRequest, SetManagedStoreSettingsForOrgRequest, SetManagedStoreSettingsForOrgResponse, SetMarketplaceMavenGroupRequest, SetMarketplaceMavenGroupResponse, SetPresetFromSourceRequest, SetPresetResolvedShapesOverridesRequest, SetProjectImmutabilityRequest, SetProjectImmutabilityResponse, SetProjectMutabilityAllowance, SetProjectMutabilityAllowance_allowed, SetProjectMutabilityAllowance_disallowed, SetProjectMutabilityDisallowedRationale, SetProjectMutabilityDisallowedRationale_permissionDenied, SetProjectMutabilityDisallowedRationale_resourceIsNotProject, SetProjectMutabilityPermissionDenied, SetReleaseChannelsForBlockSetVersionRequest, SetTargetInstallLocation, SetTargetInstallation, Sha256Hash, ShapeDisplayMetadata, ShapeDisplayMetadata_action, ShapeDisplayMetadata_actionParameter, ShapeDisplayMetadata_allowOntologySchemaMigrations, ShapeDisplayMetadata_appConfigTitanium, ShapeDisplayMetadata_artifactsRepository, ShapeDisplayMetadata_authoringLibrary, ShapeDisplayMetadata_authoringRepository, ShapeDisplayMetadata_automation, ShapeDisplayMetadata_autopilotWorkbench, ShapeDisplayMetadata_blobsterResource, ShapeDisplayMetadata_carbonWorkspace, ShapeDisplayMetadata_checkpointConfig, ShapeDisplayMetadata_cipherChannel, ShapeDisplayMetadata_cipherLicense, ShapeDisplayMetadata_cipherLicenseV2, ShapeDisplayMetadata_codeWorkspace, ShapeDisplayMetadata_codeWorkspaceLicense, ShapeDisplayMetadata_compassResource, ShapeDisplayMetadata_contourAnalysis, ShapeDisplayMetadata_contourRef, ShapeDisplayMetadata_dataHealthCheck, ShapeDisplayMetadata_dataHealthCheckGroup, ShapeDisplayMetadata_datasourceColumn, ShapeDisplayMetadata_deployedApp, ShapeDisplayMetadata_eddieEdgePipeline, ShapeDisplayMetadata_eddieGeotimeConfiguration, ShapeDisplayMetadata_eddieParameter, ShapeDisplayMetadata_eddieParameterV2, ShapeDisplayMetadata_eddiePipeline, ShapeDisplayMetadata_eddieReplayOption, ShapeDisplayMetadata_edgePipelineMagritteSource, ShapeDisplayMetadata_evaluationSuite, ShapeDisplayMetadata_filesDatasource, ShapeDisplayMetadata_flinkProfile, ShapeDisplayMetadata_function, ShapeDisplayMetadata_functionConfiguration, ShapeDisplayMetadata_functionPackageConfiguration, ShapeDisplayMetadata_fusionDocument, ShapeDisplayMetadata_geotimeSeriesIntegration, ShapeDisplayMetadata_installPrefix, ShapeDisplayMetadata_interfaceActionTypeConstraint, ShapeDisplayMetadata_interfaceLinkType, ShapeDisplayMetadata_interfaceParameterConstraint, ShapeDisplayMetadata_interfacePropertyType, ShapeDisplayMetadata_interfaceType, ShapeDisplayMetadata_languageModel, ShapeDisplayMetadata_linkType, ShapeDisplayMetadata_logic, ShapeDisplayMetadata_logicFunction, ShapeDisplayMetadata_machinery, ShapeDisplayMetadata_magritteConnection, ShapeDisplayMetadata_magritteExport, ShapeDisplayMetadata_magritteExtract, ShapeDisplayMetadata_magritteSource, ShapeDisplayMetadata_magritteStreamingExtract, ShapeDisplayMetadata_markings, ShapeDisplayMetadata_model, ShapeDisplayMetadata_modelStudio, ShapeDisplayMetadata_modelStudioConfig, ShapeDisplayMetadata_monocleGraph, ShapeDisplayMetadata_multipassGroup, ShapeDisplayMetadata_multipassUserAttribute, ShapeDisplayMetadata_namedCredential, ShapeDisplayMetadata_networkEgressPolicy, ShapeDisplayMetadata_notepadDocument, ShapeDisplayMetadata_notepadTemplate, ShapeDisplayMetadata_notepadTemplateParameter, ShapeDisplayMetadata_objectInstance, ShapeDisplayMetadata_objectSet, ShapeDisplayMetadata_objectType, ShapeDisplayMetadata_objectView, ShapeDisplayMetadata_objectViewTab, ShapeDisplayMetadata_ontologyDatasource, ShapeDisplayMetadata_ontologySdk, ShapeDisplayMetadata_ontologySdkV2, ShapeDisplayMetadata_parameter, ShapeDisplayMetadata_property, ShapeDisplayMetadata_quiverDashboard, ShapeDisplayMetadata_resourceUpdatesContent, ShapeDisplayMetadata_rosettaDocsBundle, ShapeDisplayMetadata_schedule, ShapeDisplayMetadata_sharedPropertyType, ShapeDisplayMetadata_simple, ShapeDisplayMetadata_slateApplication, ShapeDisplayMetadata_solutionDesign, ShapeDisplayMetadata_sparkProfile, ShapeDisplayMetadata_sqlWorksheet, ShapeDisplayMetadata_storedProcedure, ShapeDisplayMetadata_tabularDatasource, ShapeDisplayMetadata_taurusWorkflow, ShapeDisplayMetadata_thirdPartyApplication, ShapeDisplayMetadata_timeSeriesSync, ShapeDisplayMetadata_transformsJobSpec, ShapeDisplayMetadata_valueType, ShapeDisplayMetadata_vectorWorkbook, ShapeDisplayMetadata_versionedObjectSet, ShapeDisplayMetadata_vertexTemplate, ShapeDisplayMetadata_vortexTemplate, ShapeDisplayMetadata_walkthrough, ShapeDisplayMetadata_webhook, ShapeDisplayMetadata_workbenchTemplate, ShapeDisplayMetadata_workflowGraph, ShapeDisplayMetadata_workshopApplication, ShapeDisplayMetadata_workshopApplicationSaveLocation, ShapeDoesNotExistOnBlock, ShapeInstallationStatusBuilding, ShapeInstallationStatusFailed, ShapeInstallationStatusFinished, ShapeInstallationStatusNotStarted, ShapeInstallationStatusPendingBuild, ShapeInstallationStatusPreallocating, ShapeInstallationStatusReconciling, ShapeInstallationStatusWaitingForIndexing, ShapeInstallationStatuses, ShapeMappingInfo, ShapeReference, ShapesAffectedByMarkings, ShapesAffectedByMarkings_datasource, ShapesAffectedByMarkings_propertyType, ShapesAffectedByMarkings_thirdPartyApplication, ShapesRemovalError, SharedPropertyTypeIdentifier, SharedPropertyTypeIdentifier_rid, SharedPropertyTypeInputShape, SharedPropertyTypeMissing, SharedPropertyTypeNotFound, SharedPropertyTypeOutputShape, SharedPropertyTypeReference, SharedPropertyTypeReferenceUnresolvable, SharedPropertyTypeRid, Signature, SigningKeyId, SigningPublicKey, SimpleBlockSetRecommendation, SimpleDisplayMetadata, SimpleRecommendation, SingleOutputType, SingleOutputTypeDisplayMetadata, SingleStreamMp4AudioContainerFormat, SingleStreamOggAudioContainerFormat, SingleStreamWebmAudioContainerFormat, SingleVersionBlockReference, SlateApplicationIdentifier, SlateApplicationIdentifier_rid, SlateApplicationInputShape, SlateApplicationOutputShape, SlateCreateBlockRequest, SlsVersion, SnapshotMemberVersion, SoftDeleteDisable, SoftDeleteMode, SoftDeleteMode_disable, SoftDeleteMode_skip, SoftDeleteMode_trash, SoftDeleteSkip, SoftDeleteTrash, SoftDeleteUninstallOptions, SolutionDesignCreateBlockRequest, SolutionDesignIdentifier, SolutionDesignShape, SparkProfileConstraint, SparkProfileConstraintViolated, SparkProfileConstraint_allowedProfileNames, SparkProfileConstraint_profileFamily, SparkProfileFamilyMismatch, SparkProfileFamilyName, SparkProfileIdentifier, SparkProfileIdentifierConstraint, SparkProfileIdentifierConstraint_allowedProfileNames, SparkProfileIdentifierConstraint_sameProfileFamily, SparkProfileIdentifier_name, SparkProfileIdentifier_nameConstrained, SparkProfileIdentifier_rid, SparkProfileName, SparkProfileNameConstrained, SparkProfileRid, SparkProfileShape, SpecificRemoteStrategy, SpecsSettings, SpreadsheetDecodeFormat, SpreadsheetDecodeFormat_xlsx, SpreadsheetSchema, SqlWorksheetCreateBlockRequest, SqlWorksheetEntityIdentifier, SqlWorksheetShape, SqlWorksheetVersion, SqlWorksheetVersion_uuid, StableBlockKey, StableBlockKey_rid, StableFunctionsApiStabilityConfiguration, StableShapeIdentifier, StaleRecommendation, StaticDatasetCreateBlockRequest, StemmaRepositoryType, StoreMetadata, StoreName, StoredProcedureCreateBlockRequest, StoredProcedureEntityIdentifier, StoredProcedureShape, StreamDatasetCreateBlockRequest, StreamLocator, StreamLocatorIdentifier, StreamingVideoContainerFormat, StreamingVideoContainerFormat_cmaf, StreamingVideoContainerFormat_webm, StreamingVideoSchema, StrictFolderTrackingInvalidDiscoverySpec, StrictFolderTrackingInvalidProvenance, StrictFolderTrackingMultipleDiscoverySpecs, StrictFolderTrackingNoDiscoverySpec, StringListType, StringMismatchError, StringType, StringValue, StringVersion, StructFieldBaseParameterType, StructFieldBaseParameterType_boolean, StructFieldBaseParameterType_date, StructFieldBaseParameterType_double, StructFieldBaseParameterType_geohash, StructFieldBaseParameterType_geoshape, StructFieldBaseParameterType_integer, StructFieldBaseParameterType_long, StructFieldBaseParameterType_objectReference, StructFieldBaseParameterType_string, StructFieldBaseParameterType_timestamp, StructFieldRid, StructFieldTypeUnsupported, StructListType, StructParameterFieldApiName, StructPropertyType, StructType, StructV2BaseType, SubmitJobDraftRequest, SubmitJobDraftResponse, SuccessGranularOutputSpecResult, SupportedMarkingsType, SupportedMarkingsTypeV2, SystemId, TabularDatasourceInputIdentifier, TabularDatasourceInputShape, TabularDatasourceOutputIdentifier, TabularDatasourceOutputShape, TabularDatasourceReference, TabularDatasourceReferenceMismatch, TabularDatasourceReferenceUnresolvable, TabularDatasourceType, TabularDatasourceTypeNotSupported, Tag, TagOrDigest, TagOrDigest_digest, TagOrDigest_tag, TagRid, TargetCompassInstallLocation, TargetCompassInstallLocationV2, TargetEnvironment, TargetInputShape, TargetInstallLocation, TargetInstallLocationDoesNotMatchCurrentLocation, TargetInstallLocationV2, TargetInstallLocationV3, TargetInstallation, TargetInstallationOverrides, TargetInstallationSpec, TargetInstallationSummary, TargetOntologyIsNotLinkedToTargetNamespace, TargetRegistrationLocation, TaurusCreateBlockRequest, TaurusWorkflowIdentifier, TaurusWorkflowIdentifier_rid, TaurusWorkflowRidIdentifier, TaurusWorkflowShape, TemplatesContourCreateBlockRequest, TemplatesCreateBlockRequest, TemplatesCreateBlockRequest_contour, ThirdPartyApplicationCreateBlockRequest, ThirdPartyApplicationEntityIdentifier, ThirdPartyApplicationReference, ThirdPartyApplicationRid, ThirdPartyApplicationShape, TiffFormat, TimeSeriesReferenceType, TimeSeriesSyncCreateBlockRequest, TimeSeriesSyncRid, TimeSeriesSyncShape, TimeSeriesSyncType, TimestampListType, TimestampType, TitleOverride, TitleOverrideRequest, TitleOverrideRequest_remove, TitleOverrideRequest_set, ToBeAppliedExternalRecommendationV2, TopLevelAutomapping, TransformsCreateBlockRequest, TransformsJobSpecShape, TransformsRequestPermit, TransportBlockSetInputGroups, TransportBlockSetInputShapes, TransportBlockSetOutputShapes, TransportBlockSetToBlockMapping, TransportInputBlockSetMappingInfo, TransportOutputBlockSetMappingInfo, TransportPackagingMetadata, TransportReleaseMetadata, TransportVersionedMarketplaceMetadata, TsVideoContainerFormat, TxtFormat, TypedBlockInstallServiceValidationError, TypedBlockInstallValidationError, UnexpectedNonOptionalFunctionInput, UnexpectedNonOptionalFunctionInputV2, UnfulfilledInput, UnfulfilledInputShape, UnhandledValidationFailure, UnhandledValidationFailureV2, UnhandledValidationFailureV3, UninstallError, UninstallError_nonEmptyCompassInstallLocation, UninstallMode, UninstallMode_fieldTestPermanentlyDelete, UninstallMode_permanentlyDelete, UninstallMode_softDelete, UninstallRequest, UninstallResponse, UninstallResponseFailure, UninstallResponseSuccess, UninstallResponse_failure, UninstallResponse_success, UnknownMarketplaceCreateBlockVersionError, UnresolvableBlockSetCycle, UnresolvedJobDraft, UnresolvedProductGroupMember, UnspecifiedParameterType, UnusedShapeStatusEntry, UpdateAboutRequest, UpdateAboutRequest_set, UpdateBlockSetMetadataRequest, UpdateBlockSetMetadataResponse, UpdateBlockSetVersionChangelogRequest, UpdateBlockSetVersionChangelogResponse, UpdateBlockSetVersionDocumentationRequest, UpdateBlockSetVersionDocumentationResponse, UpdateDefaultInstallationSettingsRequest, UpdateDefaultInstallationSettingsRequest_remove, UpdateDefaultInstallationSettingsRequest_set, UpdateExternalRecsRequestId, UpdateJobDraftRequest, UpdateJobDraftResponse, UpdateKeyRequest, UpdateKeyResponse, UpdateMarketplaceMetadataVersionRequest, UpdateMarketplaceMetadataVersionRequest_remove, UpdateMarketplaceMetadataVersionRequest_set, UpdatePackagingSettingsRequest, UpdatePackagingSettingsRequest_remove, UpdatePackagingSettingsRequest_set, UpdatePendingBlockSetVersionMetadataRequest, UpdatePendingBlockSetVersionMetadataRequestV3, UpdatePendingBlockSetVersionMetadataResponse, UpdatePendingBlockSetVersionMetadataResponseV3, UpdatePendingBlockSetVersionSpecsRequest, UpdatePendingBlockSetVersionSpecsRequestId, UpdatePendingBlockSetVersionSpecsResponse, UpdatePendingInputShapeAboutRequest, UpdatePendingInputShapeMetadataRequest, UpdatePlaceholderRequest, UpdatePlaceholdersRequest, UpdatePlaceholdersResponse, UpdatePresetsRequest, UpdatePresetsRequest_remove, UpdatePresetsRequest_set, UpdateRecommendationMetadataRequest, UpdateRecommendationMetadataResponse, UpdateTagsV2Request, UpdateTagsV2Request_set, UpdateTypedTagsRequest, UpdateTypedTagsRequest_set, UpdateVersionIncrementRequest, UpdateVersionIncrementRequest_remove, UpdateVersionIncrementRequest_set, UpdateVisibilityRequest, UpdateVisibilityRequest_remove, UpdateVisibilityRequest_set, UpdatedAtTimestamp, UpgradeOfSingletonBlockSetThatIsInstalledMultipleTimes, UpgradeType, UpgradingStatus, UploadAttachmentResponse, UploadingStatusV3, UpstreamRecommendation, Url, UserManagedValueTypeIdentifier, UuidVersion, ValidProductGroupValidationStatus, ValidateBlockSetVersionResponse, ValidateInstallBlockSetsResponse, ValidateInstallBlocksResponse, ValidateMarketplaceMavenGroupFailure, ValidateMarketplaceMavenGroupFailure_groupAlreadyUsed, ValidateMarketplaceMavenGroupFailure_groupMalformed, ValidateMarketplaceMavenGroupFailure_other, ValidateMarketplaceMavenGroupRequest, ValidateMarketplaceMavenGroupResponse, ValidateMarketplaceMavenGroupResponse_failure, ValidateMarketplaceMavenGroupResponse_success, ValidateMarketplaceMavenGroupSuccess, ValidateProductsRequest, ValidateProductsResponse, ValueTypeApiName, ValueTypeBaseTypeMismatch, ValueTypeCreateBlockRequest, ValueTypeNotFound, ValueTypePresetResolver, ValueTypePresetResolver_serviceManaged, ValueTypePresetResolver_userManaged, ValueTypeReference, ValueTypeRid, ValueTypeShape, ValueTypeShapeValidationError, ValueTypeShapeValidationError_valueTypeBaseTypeMismatch, ValueTypeShapeValidationError_valueTypeNotFound, ValueTypeShapeValidationError_valueTypeVersionNotFound, ValueTypeVersion, ValueTypeVersionId, ValueTypeVersionNotFound, VectorPropertyType, VectorSimilarityFunction, VectorWorkbookIdentifier, VectorWorkbookShape, VersionIncrement, VersionRangeBlockReference, VersionRangeBlockSetReference, VersionRangeBlockSetReference_external, VersionRangeBlockSetReference_internal, VersionedMarketplaceMetadata, VersionedObjectSetCreateBlockRequest, VersionedObjectSetEntityIdentifier, VersionedObjectSetNotLatestError, VersionedObjectSetRid, VersionedObjectSetShape, VersionedObjectSetVersion, VersionedProductGroupDefinition, VersionedValueTypeIdentifier, VertexCreateBlockRequest, VertexEntityIdentifier, VertexTemplateShape, VideoDecodeFormat, VideoDecodeFormat_mkv, VideoDecodeFormat_mov, VideoDecodeFormat_mp4, VideoDecodeFormat_ts, VideoSchema, VirtualTableCreateBlockRequest, VirtualTableLocator, VirtualTableLocatorIdentifier, Void, VoidOutputType, VorbisFormat, VortexCreateBlockRequest, VortexEntityIdentifier, VortexTemplateShape, WalkthroughCreateBlockRequest, WalkthroughEntityIdentifier, WalkthroughShape, WarehouseId, WarehouseInternalId, WarnProductGroupValidationStatus, WavFormat, WebhookEntityIdentifier, WebhookRid, WebhookShape, WebhookVersion, WebhooksCreateBlockRequest, WebmAudioCodec, WebmAudioContainerFormat, WebmAudioContainerFormat_singleStream, WebmStreamingFormat, WebmVideoCodec, WebpFormat, WidgetIdentifier, WidgetIdentifier_ridAndVersion, WidgetReference, WidgetRid, WidgetRidAndVersionIdentifier, WidgetSetCreateBlockRequest, WidgetSetIdentifier, WidgetSetIdentifier_ridAndVersion, WidgetSetReference, WidgetSetRid, WidgetSetRidAndVersionIdentifier, WidgetSetShape, WidgetSetVersion, WidgetShape, WindowStartOrEnd, WorkbenchTemplateCreateBlockRequest, WorkbenchTemplateIdentifier, WorkbenchTemplateRid, WorkbenchTemplateShape, WorkflowBuilderGraphCreateBlockRequest, WorkflowBuilderGraphIdentifier, WorkflowBuilderGraphIdentifier_rid, WorkflowBuilderGraphShape, WorkflowBuilderRid, WorkflowBuilderVersion, WorkflowGraphCreateBlockRequest, WorkflowGraphIdentifier, WorkflowGraphShape, WorkshopApplicationCompassLocationShortcuts, WorkshopApplicationInputShape, WorkshopApplicationOutputShape, WorkshopApplicationSaveLocation, WorkshopApplicationSaveLocationInputShape, WorkshopApplicationSaveLocationPartialResolvedShape, WorkshopApplicationSaveLocation_compass, WorkshopCreateBlockRequest, WorkshopIdentifier, WorkshopIdentifier_rid, WorkshopRid, WritebackCreateBlockRequest, XlsxFormat, ZoneId };